SlideShare une entreprise Scribd logo
1  sur  50
palais des
congrès
Paris



7, 8 et 9
février 2012
Les nouveautés de C++
Ecrire du code C++ Moderne (LAN207)

Christophe Pichaud      Alain Zanchetta
Consultant Architecte   Consultant Architecte
Sogeti                  Microsoft
C++
Pourquoi cette session C++ ?
  Beaucoup de développeurs connaissent le C++ mais n’en écrivent
  qu’occasionnellement
     Utilisation tactique (Win32, COM): plus du C que du C++
     Manque de temps pour suivre les évolutions du langage

     Le C++ fait peur…

  Il se passe « enfin » quelque chose dans le monde C++
     Regain d’intérêt de la part des développeurs

     Evolutions du langage – standard C++ 11
  Cette présentation montre le nouveau visage du C++
     Plus simple, plus sûr
     Et toujours aussi performant !
     Level 400 => 200
Pourquoi choisir C++ ?
  “The going word at Facebook is that ‘reasonably written
  C++ code just runs fast,’ which underscores the enormous
  effort spent at optimizing PHP and Java code. Paradoxically,
  C++ code is more difficult to write than in other languages, but
  efficient code is a lot easier.” – Andrei Alexandrescu
La normalisation du C++
  The C++ Standards Commitee
    http://www.open-std.org/jtc1/sc22/wg21/


  2011 : Approbation du standard C++0x
       Amélioration de l’implémentation dans « VC++ 11 »

    2008: Draft pour C++0x

       Implémentation (partielle) dans Visual C++ 2010

    2005: TR1= Library Technical Report 1

       Visual C++ 2008 + TR 1
    2003: TC1 = corrections C++98

    1998: C++ devient un standard ISO (« C++98 »)
TR1..           C++0x.. C++                    11
TR1 - Technical Report 1   C++ 0x
shared_ptr<T>              lambdas
                                               future<T>
weak_ptr<T>                r-value reference
                                               vector<vector<int>>
unique_ptr<T>              auto
                                               variadic templates
regex                      decltype
                                               …
tuple                      static_assert
array                      Thread
…                          mutex
C++, mythes et réalités
                     principes et techniques                  gestion des erreurs
 pointers
                                      Code crado mais je continue
        Un langage orienté objet                                         cast
                                          sur le même modèle…
           compliqué !
                             Orienté objet          Compliqué à apprendre !
  Des macros et de goto !
                                    Peu productif !    Structure de données
       Bas niveau ! Interfaces riches                      compactes et efficaces
  Non sécurisée, dangereux !                   Template meta-programming

      C’est du C !                                     Code dur à maintenir
                            new / delete
    Un bon code                                       le style C++ 11
C++ refreshed
Illustration
   Soit un point A
   Soit un ensemble de polygones
   Trouver le premier polygone qui contient A
   NB: ce n’est pas un problème de mathématiques
   mais une petite illustration de l’évolution du C++
   
C++ « classique »                               C#
CPolygon *Search(int x, int y)                  Polygon Search(int x,
{
  CPoint pt(x,y);                                              int y)
  vector<CPolygon*> polys;                      {
  ReadPolys(polys);
  CPolygon *ret = NULL;                           Point pt
  for (vector<CPolygon*>::iterator                     = new Point(x,y);
          beg = polys.begin();
          beg!=polys.end();++beg) {               List<Polygon> polys
    if ((*beg)->Contains(pt)) {                        = ReadPolys();
       ret = *beg;
       break;                                     return polys.FirstOrDefault(
     }                                              p => p.Contains(pt));
  }
  for (vector<CPolygon*>::iterator              }
           beg = polys.begin();
           beg!=polys.end();++beg)
    if ((*beg) && (*bet != ret)) delete *beg;
  return ret;
}


 11
Gestion de la mémoire
     Plus grosse « difficulté du C++ » : la gestion de mémoire
         difficile d’éviter les fuites, les doubles libérations, l’utilisation de zones déjà libérées
         Il n’y a pas de manière unique d’allouer la mémoire en C++
     Mais il y a un mécanisme de libération déterministe :
                                                                               Cycle de vie aussuré par
                                                                                le scope, avec création
class widget {       Gestion automatique       void f() {                      du membre gadget w.g.
                      du cyle de vie lié à       widget w;
private:               l’objet contenant
 gadget g;                                       :::
public:                                          w.draw();
 void draw();                                    :::                                 Destruction
};                                             }                                 automatique et de-
                                                                                allocation de w et w.g
Libération déterministe
  Principe
      RAII = Resource Acquisition Is Initialisation
      Applicable à toutes les ressources « précieuses :
           Mémoire
           fichiers, sockets, handles Windows
      Destruction déterministe (i.e. pas besoin de « using »)



   “C++ is the best language for garbage collection principally
                because it creates less garbage.”
                        Bjarne Stroustrup
Caractéristiques de
shared_ptr<T> dans <memory>
  Un template C++ disponible
    shared_ptr<Polygon> sp(new Polygon());
    sp->Draw(…);
    return sp;
   Basé sur le comptage de références
   Gain de productivité & robustesse importants avec impact minimal sur les perfs
   Compatible avec les conteneurs STL
   Compatible avec le polymorphisme :
       shared_ptr<Derived> est convertible en shared_ptr<Base>
       Ne casse pas le mécanisme de comptage des références
   Libération particulière :
    shared_ptr<int> sp((int*)CoTaskMemAlloc(sizeof(int)),
                             CoTaskMemFree);
shared_ptr est Non-Intrusif
  Possibilité d’instancier shared_ptr<T> sans modifier T
  La gestion des références (uses/weaks) est dans le
  shared_ptr
  Fonctionne avec les types prédéfinis: shared_ptr<int>
  S’incorpore dans le code sans modifier les types existants
  Un même type peut être manipulé parfois via un
  shared_ptr et d’autres fois via d’autres mécanismes
make_shared<T>()
  VS 2008 SP1 (VC9 SP1):
   shared_ptr<T> sp(new T(args));
   shared_ptr<T> sp(new T(args), del, alloc);
  VS 2010 (VC10):
   shared_ptr<T> sp = make_shared<T>(args);
   voire auto sp = make_shared<T>(args);

   shared_ptr<T> sp = allocate_shared<T>(alloc, args);
   voire auto sp = allocate_shared<T>(alloc, args);
  Simple et élegant
      Écrire le type T une seule fois
  Performant
      Une seule allocation pour l’objet et le bloc de comptage
Casser les cycles avec weak_ptr<T>
             Patterns : parent / enfants, observer
             Solution : weak_ptr<T>, lock(), expired()
               lock : transformation en shared_ptr

               expired : tester si la ressource est disponible

static void do_lock (const char *title, weak_ptr<resource> wp)
{
              shared_ptr<resource> sp = wp.lock();
              show(title, sp);
}                                                                int main()
                                                                 {
int main()                                                                    // demonstrate member function expired
{                                                                             cout << boolalpha;
              // demonstrate member function lock                             shared_ptr<resource> sp(new resource);
              shared_ptr<resource> sp0(new resource);                         weak_ptr<resource> wp(sp);
              weak_ptr<resource> wp0(sp0);                                    cout << "points to resource: " << wp.expired () << 'n';
              do_lock("weak_ptr with resource", wp0);                         sp.reset ();
              sp0.reset();                                                    cout << "expired: " << wp.expired() << 'n';
              do_lock("expired weak_ptr", wp0);                               return 0;
              return 0;                                          }
}
unique_ptr<T>
  Une seule référence de l’objet
  unique_ptr<Cat> c(new Cat);
  unique_ptr<Cat> c2(Cat::Load(…));

  Remplace auto_ptr, qui est obsolète
  Compatible avec les collections STL
  (containers)
  Non copiable mais déplaçable
   unique_ptr<Cat> c(new Cat);
   unique_ptr<Dog> d;
   d.reset(new Dog);
   unique_ptr<Monster> m_src(new Monster);
   unique_ptr<Monster> m_dest(move(m_src));
Paroles d’experts !
  Effective C++, Third Edition (2005) by Scott Meyers:
    "shared_ptr may be the most widely useful
      component in TR1."

  C++ Coding Standards (2005) by Herb Sutter and Andrei
  Alexandrescu:
    "Store only values and smart pointers in containers. To
     this we add: If you use [Boost] and [C++TR104] for
     nothing else, use them for shared_ptr."
delete
C++                                          C#
shared_ptr<CPolygon> Search(int x,
CPolygon *Search(int x, int y)
{                                int y)           Polygon Search(int x,
{ CPoint pt(x,y);                                                int y)
  vector<CPolygon*> polys;
  CPoint pt(x,y);
  ReadPolys(polys);                               {
  vector<shared_ptr<CPolygon>> polys;
  CPolygon *ret = NULL;                             Point pt
  ReadPolys(polys);
  for (vector<CPolygon*>::iterator
  for (vector<shared_ptr<CPolygon>>::
         beg = polys.begin();                            = new Point(x,y);
         beg!=polys.end();++beg) {
           iterator beg = polys.begin();            List<Polygon> polys
    if ((*beg)->Contains(pt)) {
           beg!=polys.end();++beg) {                     = ReadPolys();
      ret = *beg;
     if ((*beg)->Contains(pt))
      break;
       return *beg;                                 return polys.FirstOrDefault(
}
  } }                                                 p => p.Contains(pt));
  return nullptr;
  for (vector<CPolygon*>::iterator                }
}         beg = polys.begin();
            beg!=polys.end();++beg)
      if ((*beg) && (*bet != ret)) delete *beg;
    return ret;
}
nullptr
  nullptr exprime un pointeur nul
  Ce n’est pas un int
class Foo {
public:
  Foo(const char *s);
  Foo(int n);
}
…
Foo f(NULL);
Foo f(nullptr);
NULL
auto
  Avant…
      vector<shared_ptr<CPolygon>>::iterator beg =
       polys.begin();
    long et fastidieux à écrire !
  Maintenant, avec « auto »
   auto beg = polys.begin();

   Type déduit par le compilateur

   Equivalent de « var » en C#
auto: pourquoi l’utiliser ?
   auto utilise les règles de détection d’arguments des
   templates
     const auto * p = foo et const auto& r = bar compilent

   auto...
     Réduit la taille du code et en améliore la lisibilité

     Permet d’éviter les erreurs de types, troncations, …

     Fonctionne très bien avec les types comme les
      lambdas
C++                                    C#
shared_ptr<CPolygon> Search(int x,
                            int y)
                                         Polygon Search(int x,
{                                                       int y)
  CPoint pt(x,y);                        {
  vector<shared_ptr<CPolygon>> polys;      Point pt
  ReadPolys(polys);
  for (vector<shared_ptr<CPolygon>>::           = new Point(x,y);
  for (auto beg = beg = polys.begin();
         iterator polys.begin();           List<Polygon> polys
         beg!=polys.end();
            beg != polys.end();                 = ReadPolys();
         ++beg) { {
            ++beg)
    if ((*beg)->Contains(pt))
                                           return polys.FirstOrDefault(
      return *beg;                           p => p.Contains(pt));
  }                                      }
  return nullptr;
}
Move Semantics, Perfect
Forwarding n’est pas LValue deux choses importantes :
  RValue = tout ce qui
  Les références de Rvalue permettent
       Déplacement (move semantics) : pour la performance
       Perfect forwarding: pour la généricité
              = une seule fonction générique qui accepte des arguments quelconques
               et les transmet de manière transparente à une autre fonction en
               préservant leur nature (const, lvalue, rvalue, etc)
              Ex : make_shared
    Les patterns de déplacement et de perfect forwarding sont simples à mettre en
    oeuvre
    Mais ils s’appuient sur de nouvelles règles d’initialisation, de résolution de
    surcharge, de déduction des paramètres des templates, etc.
    Les conteneurs STL sont “move aware”
Mécanique du Move / Value Types
 class my_class {                  my_class f()
   BigHugeData *data;              {
 public:                             my_class tmp;
   my_class(const my_class& src)     …
   {                                 return tmp;
    …                              }
   }
   my_class(my_class&& other)      void main()
   {                               {
     data = other.data;              my_class c = f();
     other.data = nullptr;         }
   }
   …
 };                                        Appel du Move Constructor
C++                                   C#
shared_ptr<CPolygon> Search(int x,
                            int y)
                                        Polygon Search(int x,
{                                                      int y)
  CPoint pt(x,y);                       {
  auto polys = ReadPolys(polys);
  vector<shared_ptr<CPolygon>> polys;     Point pt
  ReadPolys(polys);
  for (auto beg = polys.begin();               = new Point(x,y);
            beg != polys.end();           List<Polygon> polys
            ++beg) {                           = ReadPolys();
    if ((*beg)->Contains(pt))
      return *beg;
                                          return polys.FirstOrDefault(
  }                                         p => p.Contains(pt));
  return nullptr;                       }
}




    29
Une classe C++11 type
   une classe possède par défaut 5 opérations
    Un constructeur par copie

    Un opérateur de copie

    Un constructeur de move

    Un opérateur de move

    Un destructeur


  Attention aux implémentations par défaut
=default et =delete
    Indiquer explicitement un opérateur de copie par défault
 class Y {
   // ...
   Y& operator=(const Y&) = default;   // default copy semantics
   Y(const Y&) = default;
 }

    Indiquer l’interdiction de la copie
 class X {
  // ...
  X& operator=(const X&) = delete;     // Disallow copying
  X(const X&) = delete;
 };
Conteneurs STL                               dictionary: map (arbre) ou
                                              unordered_map (hash)

vector<string> v;                                   map<string, string> phone;
v.push_back( “Geddy Lee” );                         phone[“Alex Lifeson”] = “+1 (416) 555-1212”;


          container par défaut: vector              multimap<string, string> phone;

        compact, efficace, cache, préfetch          phone[“Neil Peart”] = “+1 (416) 555-1212”;
                                                    phone[“Neil Peart”] = “+1 (905) 555-1234”;



                                                    unordered_map<string, string> phone;
array<string,50> a;
                                                    phone[“Alex Lifeson”] = “+1 (416) 555-1212”;

           vecteur de taillle fixe: array           unordered_multimap<string, string> phone;
        compact, efficace, cache, préfetch          phone[“Neil Peart”] = “+1 (416) 555-1212”;
                                                    phone[“Neil Peart”] = “+1 (905) 555-1234”;
cbegin(), cend(), crbegin(), crend()
 vector<int> v;
 for (auto i = v.begin(); i != v.end(); ++i) {
     // i is vector<int>::iterator
 }
 for (auto i = v.crbegin(); i != v.crend(); ++i) {
     // i is vector<int>::const_iterator
 }
 // Forme préférée : begin() et end()
 for (auto i = begin(v); i != end(v); ++i) {
 …
 }
Algorithmes : trois catégories
  Parcours simples
    Exemple : for_each = le plus simple

  Parcours avec transformations
    Exemple : copy = copie tous les éléments répondant à

      une condition
  Tris
    Exemples : sort, stable_sort, lower_bound
Parcours simples
  All of
  Any of
  None of
  For each
  Find
  Find end
  Find first
  Adjacent Find
  Count
  Mismatch
  Equal
  Is permutation
  Search
Exemple : Find first
 template<class InputIterator, class Predicate>
 InputIterator find_if(InputIterator first,
                       InputIterator last,
                       Predicate pred);
   Retourne le premier élément vérifiant le prédicat
   Predicate :
     Fonctions

     Classe surchargeant operator()

     Lambda
Transformations
  Copy
  Move
  Swap
  Transform
  Replace
  Fill
  Generate
  Remove
  Unique
  Reverse
  Rotate
  Random shuffle
  Partitions
Exemple Transform
 template<class InputIterator, class OutputIterator,
                                           class UnaryOperation>
 OutputIterator transform(InputIterator first,
                          InputIterator last,
                          OutputIterator result,
                          UnaryOperation op);
   Exemple: impression de tous les éléments d’un conteneur
   :
 copy(points.begin(), points.end(),
      ostream_iterator<CPoint>(cout, "n" ));
Tri et assimilés
  Sort
  Stable_sort
  Partial_sort
  Nth element
  Binary search : lower_bound, upper_bound
  Merge
Exemple : sort
 template<class RandomAccessIterator, class Compare>
 void sort(RandomAccessIterator first,
           RandomAccessIterator last,
           Compare comp);
   Trie les éléments selon « comp »
   Comp = ordre strict (< ou > et non    ou )
 bool PlusHaut(CPoint &pt1, CPoint &pt2)
 {
   return pt1.Y() > pt2.Y();
 }
 sort(points.begin(), points.end(), PlusHaut);
Fonctions et prédicats
 Function for_each(InputIterator first, InputIterator last, Function f);
 InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);
 void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

Fonctions simples :                  Classes surchargeant () :
bool PlusHaut(CPoint &pt1,           class DistancePoint {
                                     protected:
              CPoint &pt2)              const CPoint &_ptr;
{                                    public:
  return pt1.Y() > pt2.Y();            DistancePoint(const CPoint &ptr)
}                                         : _ptr(ptr) {}

                                       bool operator()(CPoint &pt1,
                                                       CPoint &pt2) {
                Et lambdas !             return _ptr.Distance2(pt1)
                                              < _ptr.Distance2(pt2);
                                       }
                                     };
Le B.A. BA des lambdas
  Les Lambda Expressions définissent et construisent des
  classes fonctions anonymes
  La Lamba Expression
  for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });
  Est équivalente à
  struct LambdaFunctor {
      void operator()(int n) const {
          cout << n << " ";
      }
  };
  …
  for_each(v.begin(), v.end(), LambdaFunctor);
Compléments
    Une lambda peut contenir plusieurs instructions
    void par défaut, -> type pour préciser le type de retour
    [] sert à indiquer ce qu’on doit capturer du contexte
      Utilisation de variables extérieures à la lambda
v.erase(remove_if(v.begin(), v.end(), [x, y](int n) { return x < n && n < y; }), v.end());

         Lambda Stateless: []
         Les copies capturées « survivent » à leur contexte
         Possibilité de capture par référence
         Capture de toutes les variables [=] ou [&]
C++                                  C#
shared_ptr<CPolygon> Search(int x,     Polygon Search(int x,
                            int y)
                                                      int y)
{
  CPoint pt(x,y);                      {
  auto polys = ReadPolys(polys);
               ReadPolys();              Point pt
  auto found = find_if(begin(polys),          = new Point(x,y);
  for (auto beg = polys.begin();
                       end(polys),       List<Polygon> polys
    [pt](shared_ptr<CPolygon> pol) {
            beg != polys.end();               = ReadPolys();
      return++beg) {
             pol->Contains(pt);          return polys.FirstOrDefault(
    });
    if ((*beg)->Contains(pt))              p => p.Contains(pt));
  return (found != polys.end())
      return *beg;
                                       }
  }      ? *found : nullptr;
} return nullptr;
}



   44
C++ 98                                  C++ 2011
CPolygon *Search(int x, int y)            shared_ptr<CPolygon> Search(int x,
{                                                                     int y)
  CPoint pt(x,y);                         {
  vector<CPolygon*> polys;
  ReadPolys(polys);
                                            CPoint pt(x,y);
  CPolygon *ret = NULL;                     auto polys = ReadPolys();
  for (vector<CPolygon*>::iterator          auto found = find_if(begin(polys),
          beg = polys.begin();                                   end(polys),
          beg!=polys.end();++beg) {           [pt](shared_ptr<CPolygon> pol) {
    if ((*beg)->Contains(pt)) {                 return pol->Contains(pt);
       ret = *beg;                            });
}
  }
                                            return (found != polys.end())
  for (vector<CPolygon*>::iterator                 ? *found : nullptr;
           beg = polys.begin();           }
           beg!=polys.end();++beg)
    if ((*beg) && (*bet != ret)) delete
    *beg;
  return ret;
}    45
Initialisation des listes
    Maintenant, on peut écrire cela
vector<double> v = { 1, 2, 3.456, 99.99 };

list<pair<string,string>> languages = {
     {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"} };

map<vector<string>,vector<int>> years = {
 { {"Maurice","Vincent", "Wilkes"},{1913, 1945, 1951, 1967, 2000} },
 { {"Martin", "Ritchards"} {1982, 2003, 2007} },
 { {"David", "John", "Wheeler"}, {1927, 1947, 1951, 2004} } };


    L’utilisation de {} est possible via une fonction (souvent par un
    constructeur) qui accepte un argument std::initializer_list<T>
vector (std::initializer_list<E> s) // initializer-list constructor
VC++ & C++11                         Techdays 2012




     VC10               VC11           VC11            VC11     OOB           OOB
     RTM                 DP            Beta            RTM      CTP           RTM


      Apr                Sep            Feb                          Out-Of-Band
     2010               2011           2012                           Releases

                                                              + progressively roll out C++11
   + lambdas,          + complete                                initializer lists, template
   move/&&,           C++11 stdlib:            + C++11         aliases, variadic templates,
 auto, decltype,     thread/mutex,            range-for,           constexpr, noexcept,
  auto fn decls,    async, future, …            final,              =default/delete, …
extern template,    + track changes            override
    nullptr, …     (lambdas, &&, …)                           Survey: bit.ly/mscpp11
A retenir
  Systématiser l’usage des Smart Pointers = plus de delete
    shared_ptr, weak_ptr, unique_ptr, auto_ptr

    make_shared

  Oublier NULL et utiliser null_ptr
  Capitaliser sur les conteneurs et algorithmes de la STL
  Intégrer le déplacement dans les membres spéciaux
Pour aller plus loin
  Le standard C++
      http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3337.pdf
  Channel 9 : Going Deep (STL, TR1, etc)
      http://channel9.msdn.com/Shows/Going+Deep
  Channel 9 : Going Native
      http://channel9.msdn.com/Events/GoingNative/GoingNative-2012
  C++ Sessions de la Build 2011
      http://channel9.msdn.com/Events/BUILD/BUILD2011?sort=status&direction=
       asc&t%5B0%5D=c%2B%2B#tab_sortBy_status
  What's New for Visual C++ in Visual Studio 11 Developer Preview
      http://msdn.microsoft.com/en-us/library/hh409293(v=vs.110).aspx
  Blog équipe VC++
      http://blogs.msdn.com/b/vcblog/
Pour aller plus loin
  Chaque semaine, les DevCamps                        Prochaines sessions des Dev Camps
                                                      10 février                  Open Data - Développer des applications riches avec le protocole Open
                                                                   Live Meeting
  ALM, Azure, Windows Phone, HTML5, OpenData            2012                      Data

  http://msdn.microsoft.com/fr-fr/devcamp             16 février
                                                        2012
                                                                   Live Meeting
                                                                                  Azure series - Développer des applications sociales sur la plateforme
                                                                                  Windows Azure

                                                      17 février
                                                                   Live Meeting   Comprendre le canvas avec Galactic et la librairie three.js
                                                        2012

  Téléchargement, ressources et                       21 février
                                                        2012
                                                                   Live Meeting   La production automatisée de code avec CodeFluent Entities

  toolkits : RdV sur MSDN                              2 mars
                                                        2012
                                                                   Live Meeting
                                                                                  Comprendre et mettre en oeuvre le toolkit Azure pour Windows Phone 7,
                                                                                  iOS et Android
  http://msdn.microsoft.com/fr-fr/
                                                       6 mars
                                                                   Live Meeting   Nuget et ALM
                                                        2012



  Les offres à connaître
                                                       9 mars
                                                                   Live Meeting   Kinect - Bien gérer la vie de son capteur
                                                        2012

                                                      13 mars
         90 jours d’essai gratuit de Windows Azure     2012
                                                                   Live Meeting   Sharepoint series - Automatisation des tests


          www.windowsazure.fr                         14 mars
                                                       2012
                                                                   Live Meeting
                                                                                  TFS Health Check - vérifier la bonne santé de votre plateforme de
                                                                                  développement

                                                      15 mars                     Azure series - Développer pour les téléphones, les tablettes et le cloud
         Jusqu’à 35% de réduction sur Visual Studio    2012
                                                                   Live Meeting
                                                                                  avec Visual Studio 2010

         Pro, avec l’abonnement MSDN                  16 mars
                                                       2012
                                                                   Live Meeting
                                                                                  Applications METRO design - Désossage en règle d'un template METRO
                                                                                  javascript
          www.visualstudio.fr                         20 mars
                                                                   Live Meeting
                                                                                  Retour d'expérience LightSwitch, Optimisation de l'accès aux données,
                                                       2012                       Intégration Silverlight

                                                      23 mars
                                                                   Live Meeting   OAuth - la clé de l'utilisation des réseaux sociaux dans votre application
                                                       2012

Contenu connexe

Tendances

C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieLoic Yon
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Aziz Darouichi
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesECAM Brussels Engineering School
 
Python For Data Science - French Course
Python For Data Science - French CoursePython For Data Science - French Course
Python For Data Science - French CourseHaytam EL YOUSSFI
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objetsAziz Darouichi
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage PythonAziz Darouichi
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateursAziz Darouichi
 
Formation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduraleFormation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduralekemenaran
 
Cours langage c
Cours langage cCours langage c
Cours langage ccoursuniv
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMALoic Yon
 
Cours c#
Cours c#Cours c#
Cours c#zan
 
Chap1V2019: Cours en C++
Chap1V2019: Cours en C++Chap1V2019: Cours en C++
Chap1V2019: Cours en C++Aziz Darouichi
 
Comment développer un serveur métier en python/C++
Comment développer un serveur métier en python/C++Comment développer un serveur métier en python/C++
Comment développer un serveur métier en python/C++cppfrug
 
Développement informatique : Algorithmique I : Récursion et arbre
Développement informatique : Algorithmique I : Récursion et arbreDéveloppement informatique : Algorithmique I : Récursion et arbre
Développement informatique : Algorithmique I : Récursion et arbreECAM Brussels Engineering School
 
C++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistC++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistVincent Agnus
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfacesAziz Darouichi
 
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...cppfrug
 

Tendances (20)

C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
 
Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références Chapitre4: Pointeurs et références
Chapitre4: Pointeurs et références
 
Polymorphisme, interface et classe abstraite
Polymorphisme, interface et classe abstraitePolymorphisme, interface et classe abstraite
Polymorphisme, interface et classe abstraite
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de données
 
Python For Data Science - French Course
Python For Data Science - French CoursePython For Data Science - French Course
Python For Data Science - French Course
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objets
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateurs
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
 
Formation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduraleFormation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procédurale
 
Cours langage c
Cours langage cCours langage c
Cours langage c
 
Cours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMACours de C++ / Tronc commun deuxième année ISIMA
Cours de C++ / Tronc commun deuxième année ISIMA
 
Cours c#
Cours c#Cours c#
Cours c#
 
Chap1V2019: Cours en C++
Chap1V2019: Cours en C++Chap1V2019: Cours en C++
Chap1V2019: Cours en C++
 
Comment développer un serveur métier en python/C++
Comment développer un serveur métier en python/C++Comment développer un serveur métier en python/C++
Comment développer un serveur métier en python/C++
 
C# langage & syntaxe
C#   langage & syntaxeC#   langage & syntaxe
C# langage & syntaxe
 
Développement informatique : Algorithmique I : Récursion et arbre
Développement informatique : Algorithmique I : Récursion et arbreDéveloppement informatique : Algorithmique I : Récursion et arbre
Développement informatique : Algorithmique I : Récursion et arbre
 
C++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelistC++ Metaprogramming : multidimensional typelist
C++ Metaprogramming : multidimensional typelist
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfaces
 
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...
Du Polymorphisme dynamique au polymorphisme statique : Abstraction sans perte...
 

Similaire à Les nouveautés de C++11 : Ecrire du C++ Moderne

Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Laurent BUNIET
 
System c eniso_jan_fev_07
System c eniso_jan_fev_07System c eniso_jan_fev_07
System c eniso_jan_fev_07haythem_2015
 
Cours de C++, en français, 2002 - Cours 1.5
Cours de C++, en français, 2002 - Cours 1.5Cours de C++, en français, 2002 - Cours 1.5
Cours de C++, en français, 2002 - Cours 1.5Laurent BUNIET
 
Découvrez C# 4.0 et les améliorations apportées à la BCL
Découvrez C# 4.0 et les améliorations apportées à la BCLDécouvrez C# 4.0 et les améliorations apportées à la BCL
Découvrez C# 4.0 et les améliorations apportées à la BCLDotNetHub
 
Interception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelInterception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelThierry Gayet
 
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++Microsoft
 
C++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in ParisC++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in Parischristophep21
 
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES (2022-2023)
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES  (2022-2023)IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES  (2022-2023)
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES (2022-2023)Tunisie collège
 
Visual Studio 2008 Overview
Visual Studio 2008 OverviewVisual Studio 2008 Overview
Visual Studio 2008 OverviewGregory Renard
 
02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSSAyoubElmrabet6
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++coursuniv
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptxolfaharrabi2
 
Programmation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulationProgrammation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulationECAM Brussels Engineering School
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logiciellecyrilgandon
 
Cours de C++, en français, 2002 - Cours 3.5
Cours de C++, en français, 2002 - Cours 3.5Cours de C++, en français, 2002 - Cours 3.5
Cours de C++, en français, 2002 - Cours 3.5Laurent BUNIET
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Loic Yon
 
11-Concurrence-Section critiques.pdf
11-Concurrence-Section critiques.pdf11-Concurrence-Section critiques.pdf
11-Concurrence-Section critiques.pdfPatiento Del Mar
 

Similaire à Les nouveautés de C++11 : Ecrire du C++ Moderne (20)

Part1
Part1Part1
Part1
 
Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1Cours de C++, en français, 2002 - Cours 2.1
Cours de C++, en français, 2002 - Cours 2.1
 
System c eniso_jan_fev_07
System c eniso_jan_fev_07System c eniso_jan_fev_07
System c eniso_jan_fev_07
 
Cours de C++, en français, 2002 - Cours 1.5
Cours de C++, en français, 2002 - Cours 1.5Cours de C++, en français, 2002 - Cours 1.5
Cours de C++, en français, 2002 - Cours 1.5
 
Découvrez C# 4.0 et les améliorations apportées à la BCL
Découvrez C# 4.0 et les améliorations apportées à la BCLDécouvrez C# 4.0 et les améliorations apportées à la BCL
Découvrez C# 4.0 et les améliorations apportées à la BCL
 
Interception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appelInterception de signal avec dump de la pile d'appel
Interception de signal avec dump de la pile d'appel
 
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
 
C++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in ParisC++ 11 - Tech Days 2014 in Paris
C++ 11 - Tech Days 2014 in Paris
 
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES (2022-2023)
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES  (2022-2023)IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES  (2022-2023)
IMPLEMENTATION EN PYTHON DES CONVENTIONS ALGORITHMIQUES (2022-2023)
 
Visual Studio 2008 Overview
Visual Studio 2008 OverviewVisual Studio 2008 Overview
Visual Studio 2008 Overview
 
02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSS
 
POO-chapitre2.pptx
POO-chapitre2.pptxPOO-chapitre2.pptx
POO-chapitre2.pptx
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
 
POO-chapitre3.pptx
POO-chapitre3.pptxPOO-chapitre3.pptx
POO-chapitre3.pptx
 
Programmation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulationProgrammation orientée objet : Object, classe et encapsulation
Programmation orientée objet : Object, classe et encapsulation
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logicielle
 
Cours de C++, en français, 2002 - Cours 3.5
Cours de C++, en français, 2002 - Cours 3.5Cours de C++, en français, 2002 - Cours 3.5
Cours de C++, en français, 2002 - Cours 3.5
 
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
Java - Support etudiant - Tronc Commun Deuxième année ISIMA - 2018
 
11-Concurrence-Section critiques.pdf
11-Concurrence-Section critiques.pdf11-Concurrence-Section critiques.pdf
11-Concurrence-Section critiques.pdf
 

Plus de Microsoft

Uwp + Xamarin : Du nouveau en terre du milieu
Uwp + Xamarin : Du nouveau en terre du milieuUwp + Xamarin : Du nouveau en terre du milieu
Uwp + Xamarin : Du nouveau en terre du milieuMicrosoft
 
La Blockchain pas à PaaS
La Blockchain pas à PaaSLa Blockchain pas à PaaS
La Blockchain pas à PaaSMicrosoft
 
Tester, Monitorer et Déployer son application mobile
Tester, Monitorer et Déployer son application mobileTester, Monitorer et Déployer son application mobile
Tester, Monitorer et Déployer son application mobileMicrosoft
 
Windows 10, un an après – Nouveautés & Démo
Windows 10, un an après – Nouveautés & Démo Windows 10, un an après – Nouveautés & Démo
Windows 10, un an après – Nouveautés & Démo Microsoft
 
Prenez votre pied avec les bots et cognitive services.
Prenez votre pied avec les bots et cognitive services.Prenez votre pied avec les bots et cognitive services.
Prenez votre pied avec les bots et cognitive services.Microsoft
 
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...Microsoft
 
Créer un bot de A à Z
Créer un bot de A à ZCréer un bot de A à Z
Créer un bot de A à ZMicrosoft
 
Microsoft Composition, pierre angulaire de vos applications ?
Microsoft Composition, pierre angulaire de vos applications ?Microsoft Composition, pierre angulaire de vos applications ?
Microsoft Composition, pierre angulaire de vos applications ?Microsoft
 
Les nouveautés SQL Server 2016
Les nouveautés SQL Server 2016Les nouveautés SQL Server 2016
Les nouveautés SQL Server 2016Microsoft
 
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?Microsoft
 
Administration et supervision depuis le Cloud avec Azure Logs Analytics
Administration et supervision depuis le Cloud avec Azure Logs AnalyticsAdministration et supervision depuis le Cloud avec Azure Logs Analytics
Administration et supervision depuis le Cloud avec Azure Logs AnalyticsMicrosoft
 
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...Microsoft
 
Plan de Reprise d'Activité avec Azure Site Recovery
Plan de Reprise d'Activité avec Azure Site RecoveryPlan de Reprise d'Activité avec Azure Site Recovery
Plan de Reprise d'Activité avec Azure Site RecoveryMicrosoft
 
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...Microsoft
 
Transformation de la représentation : De la VR à la RA, aller & retour.
Transformation de la représentation : De la VR à la RA, aller & retour.Transformation de la représentation : De la VR à la RA, aller & retour.
Transformation de la représentation : De la VR à la RA, aller & retour.Microsoft
 
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...Microsoft
 
Introduction à ASP.NET Core
Introduction à ASP.NET CoreIntroduction à ASP.NET Core
Introduction à ASP.NET CoreMicrosoft
 
Open Source et Microsoft Azure, rêve ou réalité ?
Open Source et Microsoft Azure, rêve ou réalité ?Open Source et Microsoft Azure, rêve ou réalité ?
Open Source et Microsoft Azure, rêve ou réalité ?Microsoft
 
Comment développer sur la console Xbox One avec une application Universal Win...
Comment développer sur la console Xbox One avec une application Universal Win...Comment développer sur la console Xbox One avec une application Universal Win...
Comment développer sur la console Xbox One avec une application Universal Win...Microsoft
 
Azure Service Fabric pour les développeurs
Azure Service Fabric pour les développeursAzure Service Fabric pour les développeurs
Azure Service Fabric pour les développeursMicrosoft
 

Plus de Microsoft (20)

Uwp + Xamarin : Du nouveau en terre du milieu
Uwp + Xamarin : Du nouveau en terre du milieuUwp + Xamarin : Du nouveau en terre du milieu
Uwp + Xamarin : Du nouveau en terre du milieu
 
La Blockchain pas à PaaS
La Blockchain pas à PaaSLa Blockchain pas à PaaS
La Blockchain pas à PaaS
 
Tester, Monitorer et Déployer son application mobile
Tester, Monitorer et Déployer son application mobileTester, Monitorer et Déployer son application mobile
Tester, Monitorer et Déployer son application mobile
 
Windows 10, un an après – Nouveautés & Démo
Windows 10, un an après – Nouveautés & Démo Windows 10, un an après – Nouveautés & Démo
Windows 10, un an après – Nouveautés & Démo
 
Prenez votre pied avec les bots et cognitive services.
Prenez votre pied avec les bots et cognitive services.Prenez votre pied avec les bots et cognitive services.
Prenez votre pied avec les bots et cognitive services.
 
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...
Office 365 Dev PnP & PowerShell : exploitez enfin le potentiel de votre écosy...
 
Créer un bot de A à Z
Créer un bot de A à ZCréer un bot de A à Z
Créer un bot de A à Z
 
Microsoft Composition, pierre angulaire de vos applications ?
Microsoft Composition, pierre angulaire de vos applications ?Microsoft Composition, pierre angulaire de vos applications ?
Microsoft Composition, pierre angulaire de vos applications ?
 
Les nouveautés SQL Server 2016
Les nouveautés SQL Server 2016Les nouveautés SQL Server 2016
Les nouveautés SQL Server 2016
 
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?
Conteneurs Linux ou Windows : quelles approches pour des IT agiles ?
 
Administration et supervision depuis le Cloud avec Azure Logs Analytics
Administration et supervision depuis le Cloud avec Azure Logs AnalyticsAdministration et supervision depuis le Cloud avec Azure Logs Analytics
Administration et supervision depuis le Cloud avec Azure Logs Analytics
 
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...
Retour d'expérience de projets Azure IoT "large scale" (MicroServices, portag...
 
Plan de Reprise d'Activité avec Azure Site Recovery
Plan de Reprise d'Activité avec Azure Site RecoveryPlan de Reprise d'Activité avec Azure Site Recovery
Plan de Reprise d'Activité avec Azure Site Recovery
 
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...
Modélisation, déploiement et gestion des infrastructures Cloud : outils et bo...
 
Transformation de la représentation : De la VR à la RA, aller & retour.
Transformation de la représentation : De la VR à la RA, aller & retour.Transformation de la représentation : De la VR à la RA, aller & retour.
Transformation de la représentation : De la VR à la RA, aller & retour.
 
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...
Quelles architectures pour vos applications Cloud, de la VM au conteneur : ça...
 
Introduction à ASP.NET Core
Introduction à ASP.NET CoreIntroduction à ASP.NET Core
Introduction à ASP.NET Core
 
Open Source et Microsoft Azure, rêve ou réalité ?
Open Source et Microsoft Azure, rêve ou réalité ?Open Source et Microsoft Azure, rêve ou réalité ?
Open Source et Microsoft Azure, rêve ou réalité ?
 
Comment développer sur la console Xbox One avec une application Universal Win...
Comment développer sur la console Xbox One avec une application Universal Win...Comment développer sur la console Xbox One avec une application Universal Win...
Comment développer sur la console Xbox One avec une application Universal Win...
 
Azure Service Fabric pour les développeurs
Azure Service Fabric pour les développeursAzure Service Fabric pour les développeurs
Azure Service Fabric pour les développeurs
 

Les nouveautés de C++11 : Ecrire du C++ Moderne

  • 1. palais des congrès Paris 7, 8 et 9 février 2012
  • 2. Les nouveautés de C++ Ecrire du code C++ Moderne (LAN207) Christophe Pichaud Alain Zanchetta Consultant Architecte Consultant Architecte Sogeti Microsoft
  • 3. C++
  • 4. Pourquoi cette session C++ ? Beaucoup de développeurs connaissent le C++ mais n’en écrivent qu’occasionnellement  Utilisation tactique (Win32, COM): plus du C que du C++  Manque de temps pour suivre les évolutions du langage  Le C++ fait peur… Il se passe « enfin » quelque chose dans le monde C++  Regain d’intérêt de la part des développeurs  Evolutions du langage – standard C++ 11 Cette présentation montre le nouveau visage du C++  Plus simple, plus sûr  Et toujours aussi performant !  Level 400 => 200
  • 5. Pourquoi choisir C++ ? “The going word at Facebook is that ‘reasonably written C++ code just runs fast,’ which underscores the enormous effort spent at optimizing PHP and Java code. Paradoxically, C++ code is more difficult to write than in other languages, but efficient code is a lot easier.” – Andrei Alexandrescu
  • 6. La normalisation du C++ The C++ Standards Commitee  http://www.open-std.org/jtc1/sc22/wg21/ 2011 : Approbation du standard C++0x  Amélioration de l’implémentation dans « VC++ 11 »  2008: Draft pour C++0x  Implémentation (partielle) dans Visual C++ 2010  2005: TR1= Library Technical Report 1  Visual C++ 2008 + TR 1  2003: TC1 = corrections C++98  1998: C++ devient un standard ISO (« C++98 »)
  • 7. TR1.. C++0x.. C++ 11 TR1 - Technical Report 1 C++ 0x shared_ptr<T> lambdas future<T> weak_ptr<T> r-value reference vector<vector<int>> unique_ptr<T> auto variadic templates regex decltype … tuple static_assert array Thread … mutex
  • 8. C++, mythes et réalités principes et techniques gestion des erreurs pointers Code crado mais je continue Un langage orienté objet cast sur le même modèle… compliqué ! Orienté objet Compliqué à apprendre ! Des macros et de goto ! Peu productif ! Structure de données Bas niveau ! Interfaces riches compactes et efficaces Non sécurisée, dangereux ! Template meta-programming C’est du C ! Code dur à maintenir new / delete Un bon code le style C++ 11
  • 10. Illustration Soit un point A Soit un ensemble de polygones Trouver le premier polygone qui contient A NB: ce n’est pas un problème de mathématiques mais une petite illustration de l’évolution du C++ 
  • 11. C++ « classique » C# CPolygon *Search(int x, int y) Polygon Search(int x, { CPoint pt(x,y); int y) vector<CPolygon*> polys; { ReadPolys(polys); CPolygon *ret = NULL; Point pt for (vector<CPolygon*>::iterator = new Point(x,y); beg = polys.begin(); beg!=polys.end();++beg) { List<Polygon> polys if ((*beg)->Contains(pt)) { = ReadPolys(); ret = *beg; break; return polys.FirstOrDefault( } p => p.Contains(pt)); } for (vector<CPolygon*>::iterator } beg = polys.begin(); beg!=polys.end();++beg) if ((*beg) && (*bet != ret)) delete *beg; return ret; } 11
  • 12. Gestion de la mémoire Plus grosse « difficulté du C++ » : la gestion de mémoire  difficile d’éviter les fuites, les doubles libérations, l’utilisation de zones déjà libérées  Il n’y a pas de manière unique d’allouer la mémoire en C++ Mais il y a un mécanisme de libération déterministe : Cycle de vie aussuré par le scope, avec création class widget { Gestion automatique void f() { du membre gadget w.g. du cyle de vie lié à widget w; private: l’objet contenant gadget g; ::: public: w.draw(); void draw(); ::: Destruction }; } automatique et de- allocation de w et w.g
  • 13. Libération déterministe Principe  RAII = Resource Acquisition Is Initialisation  Applicable à toutes les ressources « précieuses :  Mémoire  fichiers, sockets, handles Windows  Destruction déterministe (i.e. pas besoin de « using ») “C++ is the best language for garbage collection principally because it creates less garbage.” Bjarne Stroustrup
  • 14. Caractéristiques de shared_ptr<T> dans <memory> Un template C++ disponible shared_ptr<Polygon> sp(new Polygon()); sp->Draw(…); return sp; Basé sur le comptage de références Gain de productivité & robustesse importants avec impact minimal sur les perfs Compatible avec les conteneurs STL Compatible avec le polymorphisme :  shared_ptr<Derived> est convertible en shared_ptr<Base>  Ne casse pas le mécanisme de comptage des références Libération particulière : shared_ptr<int> sp((int*)CoTaskMemAlloc(sizeof(int)), CoTaskMemFree);
  • 15. shared_ptr est Non-Intrusif Possibilité d’instancier shared_ptr<T> sans modifier T La gestion des références (uses/weaks) est dans le shared_ptr Fonctionne avec les types prédéfinis: shared_ptr<int> S’incorpore dans le code sans modifier les types existants Un même type peut être manipulé parfois via un shared_ptr et d’autres fois via d’autres mécanismes
  • 16. make_shared<T>() VS 2008 SP1 (VC9 SP1): shared_ptr<T> sp(new T(args)); shared_ptr<T> sp(new T(args), del, alloc); VS 2010 (VC10): shared_ptr<T> sp = make_shared<T>(args); voire auto sp = make_shared<T>(args); shared_ptr<T> sp = allocate_shared<T>(alloc, args); voire auto sp = allocate_shared<T>(alloc, args); Simple et élegant  Écrire le type T une seule fois Performant  Une seule allocation pour l’objet et le bloc de comptage
  • 17. Casser les cycles avec weak_ptr<T> Patterns : parent / enfants, observer Solution : weak_ptr<T>, lock(), expired()  lock : transformation en shared_ptr  expired : tester si la ressource est disponible static void do_lock (const char *title, weak_ptr<resource> wp) { shared_ptr<resource> sp = wp.lock(); show(title, sp); } int main() { int main() // demonstrate member function expired { cout << boolalpha; // demonstrate member function lock shared_ptr<resource> sp(new resource); shared_ptr<resource> sp0(new resource); weak_ptr<resource> wp(sp); weak_ptr<resource> wp0(sp0); cout << "points to resource: " << wp.expired () << 'n'; do_lock("weak_ptr with resource", wp0); sp.reset (); sp0.reset(); cout << "expired: " << wp.expired() << 'n'; do_lock("expired weak_ptr", wp0); return 0; return 0; } }
  • 18. unique_ptr<T> Une seule référence de l’objet unique_ptr<Cat> c(new Cat); unique_ptr<Cat> c2(Cat::Load(…)); Remplace auto_ptr, qui est obsolète Compatible avec les collections STL (containers) Non copiable mais déplaçable unique_ptr<Cat> c(new Cat); unique_ptr<Dog> d; d.reset(new Dog); unique_ptr<Monster> m_src(new Monster); unique_ptr<Monster> m_dest(move(m_src));
  • 19. Paroles d’experts ! Effective C++, Third Edition (2005) by Scott Meyers:  "shared_ptr may be the most widely useful component in TR1." C++ Coding Standards (2005) by Herb Sutter and Andrei Alexandrescu:  "Store only values and smart pointers in containers. To this we add: If you use [Boost] and [C++TR104] for nothing else, use them for shared_ptr."
  • 21. C++ C# shared_ptr<CPolygon> Search(int x, CPolygon *Search(int x, int y) { int y) Polygon Search(int x, { CPoint pt(x,y); int y) vector<CPolygon*> polys; CPoint pt(x,y); ReadPolys(polys); { vector<shared_ptr<CPolygon>> polys; CPolygon *ret = NULL; Point pt ReadPolys(polys); for (vector<CPolygon*>::iterator for (vector<shared_ptr<CPolygon>>:: beg = polys.begin(); = new Point(x,y); beg!=polys.end();++beg) { iterator beg = polys.begin(); List<Polygon> polys if ((*beg)->Contains(pt)) { beg!=polys.end();++beg) { = ReadPolys(); ret = *beg; if ((*beg)->Contains(pt)) break; return *beg; return polys.FirstOrDefault( } } } p => p.Contains(pt)); return nullptr; for (vector<CPolygon*>::iterator } } beg = polys.begin(); beg!=polys.end();++beg) if ((*beg) && (*bet != ret)) delete *beg; return ret; }
  • 22. nullptr nullptr exprime un pointeur nul Ce n’est pas un int class Foo { public: Foo(const char *s); Foo(int n); } … Foo f(NULL); Foo f(nullptr);
  • 23. NULL
  • 24. auto Avant…  vector<shared_ptr<CPolygon>>::iterator beg = polys.begin();  long et fastidieux à écrire ! Maintenant, avec « auto »  auto beg = polys.begin();  Type déduit par le compilateur  Equivalent de « var » en C#
  • 25. auto: pourquoi l’utiliser ? auto utilise les règles de détection d’arguments des templates  const auto * p = foo et const auto& r = bar compilent auto...  Réduit la taille du code et en améliore la lisibilité  Permet d’éviter les erreurs de types, troncations, …  Fonctionne très bien avec les types comme les lambdas
  • 26. C++ C# shared_ptr<CPolygon> Search(int x, int y) Polygon Search(int x, { int y) CPoint pt(x,y); { vector<shared_ptr<CPolygon>> polys; Point pt ReadPolys(polys); for (vector<shared_ptr<CPolygon>>:: = new Point(x,y); for (auto beg = beg = polys.begin(); iterator polys.begin(); List<Polygon> polys beg!=polys.end(); beg != polys.end(); = ReadPolys(); ++beg) { { ++beg) if ((*beg)->Contains(pt)) return polys.FirstOrDefault( return *beg; p => p.Contains(pt)); } } return nullptr; }
  • 27. Move Semantics, Perfect Forwarding n’est pas LValue deux choses importantes : RValue = tout ce qui Les références de Rvalue permettent  Déplacement (move semantics) : pour la performance  Perfect forwarding: pour la généricité  = une seule fonction générique qui accepte des arguments quelconques et les transmet de manière transparente à une autre fonction en préservant leur nature (const, lvalue, rvalue, etc)  Ex : make_shared Les patterns de déplacement et de perfect forwarding sont simples à mettre en oeuvre Mais ils s’appuient sur de nouvelles règles d’initialisation, de résolution de surcharge, de déduction des paramètres des templates, etc. Les conteneurs STL sont “move aware”
  • 28. Mécanique du Move / Value Types class my_class { my_class f() BigHugeData *data; { public: my_class tmp; my_class(const my_class& src) … { return tmp; … } } my_class(my_class&& other) void main() { { data = other.data; my_class c = f(); other.data = nullptr; } } … }; Appel du Move Constructor
  • 29. C++ C# shared_ptr<CPolygon> Search(int x, int y) Polygon Search(int x, { int y) CPoint pt(x,y); { auto polys = ReadPolys(polys); vector<shared_ptr<CPolygon>> polys; Point pt ReadPolys(polys); for (auto beg = polys.begin(); = new Point(x,y); beg != polys.end(); List<Polygon> polys ++beg) { = ReadPolys(); if ((*beg)->Contains(pt)) return *beg; return polys.FirstOrDefault( } p => p.Contains(pt)); return nullptr; } } 29
  • 30. Une classe C++11 type une classe possède par défaut 5 opérations  Un constructeur par copie  Un opérateur de copie  Un constructeur de move  Un opérateur de move  Un destructeur Attention aux implémentations par défaut
  • 31. =default et =delete Indiquer explicitement un opérateur de copie par défault class Y { // ... Y& operator=(const Y&) = default; // default copy semantics Y(const Y&) = default; } Indiquer l’interdiction de la copie class X { // ... X& operator=(const X&) = delete; // Disallow copying X(const X&) = delete; };
  • 32. Conteneurs STL dictionary: map (arbre) ou unordered_map (hash) vector<string> v; map<string, string> phone; v.push_back( “Geddy Lee” ); phone[“Alex Lifeson”] = “+1 (416) 555-1212”; container par défaut: vector multimap<string, string> phone; compact, efficace, cache, préfetch phone[“Neil Peart”] = “+1 (416) 555-1212”; phone[“Neil Peart”] = “+1 (905) 555-1234”; unordered_map<string, string> phone; array<string,50> a; phone[“Alex Lifeson”] = “+1 (416) 555-1212”; vecteur de taillle fixe: array unordered_multimap<string, string> phone; compact, efficace, cache, préfetch phone[“Neil Peart”] = “+1 (416) 555-1212”; phone[“Neil Peart”] = “+1 (905) 555-1234”;
  • 33. cbegin(), cend(), crbegin(), crend() vector<int> v; for (auto i = v.begin(); i != v.end(); ++i) { // i is vector<int>::iterator } for (auto i = v.crbegin(); i != v.crend(); ++i) { // i is vector<int>::const_iterator } // Forme préférée : begin() et end() for (auto i = begin(v); i != end(v); ++i) { … }
  • 34. Algorithmes : trois catégories Parcours simples  Exemple : for_each = le plus simple Parcours avec transformations  Exemple : copy = copie tous les éléments répondant à une condition Tris  Exemples : sort, stable_sort, lower_bound
  • 35. Parcours simples All of Any of None of For each Find Find end Find first Adjacent Find Count Mismatch Equal Is permutation Search
  • 36. Exemple : Find first template<class InputIterator, class Predicate> InputIterator find_if(InputIterator first, InputIterator last, Predicate pred); Retourne le premier élément vérifiant le prédicat Predicate :  Fonctions  Classe surchargeant operator()  Lambda
  • 37. Transformations Copy Move Swap Transform Replace Fill Generate Remove Unique Reverse Rotate Random shuffle Partitions
  • 38. Exemple Transform template<class InputIterator, class OutputIterator, class UnaryOperation> OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); Exemple: impression de tous les éléments d’un conteneur : copy(points.begin(), points.end(), ostream_iterator<CPoint>(cout, "n" ));
  • 39. Tri et assimilés Sort Stable_sort Partial_sort Nth element Binary search : lower_bound, upper_bound Merge
  • 40. Exemple : sort template<class RandomAccessIterator, class Compare> void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); Trie les éléments selon « comp » Comp = ordre strict (< ou > et non ou ) bool PlusHaut(CPoint &pt1, CPoint &pt2) { return pt1.Y() > pt2.Y(); } sort(points.begin(), points.end(), PlusHaut);
  • 41. Fonctions et prédicats Function for_each(InputIterator first, InputIterator last, Function f); InputIterator find_if(InputIterator first, InputIterator last, Predicate pred); void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); Fonctions simples : Classes surchargeant () : bool PlusHaut(CPoint &pt1, class DistancePoint { protected: CPoint &pt2) const CPoint &_ptr; { public: return pt1.Y() > pt2.Y(); DistancePoint(const CPoint &ptr) } : _ptr(ptr) {} bool operator()(CPoint &pt1, CPoint &pt2) { Et lambdas ! return _ptr.Distance2(pt1) < _ptr.Distance2(pt2); } };
  • 42. Le B.A. BA des lambdas Les Lambda Expressions définissent et construisent des classes fonctions anonymes La Lamba Expression for_each(v.begin(), v.end(), [](int n) { cout << n << " "; }); Est équivalente à struct LambdaFunctor { void operator()(int n) const { cout << n << " "; } }; … for_each(v.begin(), v.end(), LambdaFunctor);
  • 43. Compléments Une lambda peut contenir plusieurs instructions void par défaut, -> type pour préciser le type de retour [] sert à indiquer ce qu’on doit capturer du contexte  Utilisation de variables extérieures à la lambda v.erase(remove_if(v.begin(), v.end(), [x, y](int n) { return x < n && n < y; }), v.end());  Lambda Stateless: []  Les copies capturées « survivent » à leur contexte  Possibilité de capture par référence  Capture de toutes les variables [=] ou [&]
  • 44. C++ C# shared_ptr<CPolygon> Search(int x, Polygon Search(int x, int y) int y) { CPoint pt(x,y); { auto polys = ReadPolys(polys); ReadPolys(); Point pt auto found = find_if(begin(polys), = new Point(x,y); for (auto beg = polys.begin(); end(polys), List<Polygon> polys [pt](shared_ptr<CPolygon> pol) { beg != polys.end(); = ReadPolys(); return++beg) { pol->Contains(pt); return polys.FirstOrDefault( }); if ((*beg)->Contains(pt)) p => p.Contains(pt)); return (found != polys.end()) return *beg; } } ? *found : nullptr; } return nullptr; } 44
  • 45. C++ 98 C++ 2011 CPolygon *Search(int x, int y) shared_ptr<CPolygon> Search(int x, { int y) CPoint pt(x,y); { vector<CPolygon*> polys; ReadPolys(polys); CPoint pt(x,y); CPolygon *ret = NULL; auto polys = ReadPolys(); for (vector<CPolygon*>::iterator auto found = find_if(begin(polys), beg = polys.begin(); end(polys), beg!=polys.end();++beg) { [pt](shared_ptr<CPolygon> pol) { if ((*beg)->Contains(pt)) { return pol->Contains(pt); ret = *beg; }); } } return (found != polys.end()) for (vector<CPolygon*>::iterator ? *found : nullptr; beg = polys.begin(); } beg!=polys.end();++beg) if ((*beg) && (*bet != ret)) delete *beg; return ret; } 45
  • 46. Initialisation des listes Maintenant, on peut écrire cela vector<double> v = { 1, 2, 3.456, 99.99 }; list<pair<string,string>> languages = { {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"} }; map<vector<string>,vector<int>> years = { { {"Maurice","Vincent", "Wilkes"},{1913, 1945, 1951, 1967, 2000} }, { {"Martin", "Ritchards"} {1982, 2003, 2007} }, { {"David", "John", "Wheeler"}, {1927, 1947, 1951, 2004} } }; L’utilisation de {} est possible via une fonction (souvent par un constructeur) qui accepte un argument std::initializer_list<T> vector (std::initializer_list<E> s) // initializer-list constructor
  • 47. VC++ & C++11 Techdays 2012 VC10 VC11 VC11 VC11 OOB OOB RTM DP Beta RTM CTP RTM Apr Sep Feb Out-Of-Band 2010 2011 2012 Releases + progressively roll out C++11 + lambdas, + complete initializer lists, template move/&&, C++11 stdlib: + C++11 aliases, variadic templates, auto, decltype, thread/mutex, range-for, constexpr, noexcept, auto fn decls, async, future, … final, =default/delete, … extern template, + track changes override nullptr, … (lambdas, &&, …) Survey: bit.ly/mscpp11
  • 48. A retenir Systématiser l’usage des Smart Pointers = plus de delete  shared_ptr, weak_ptr, unique_ptr, auto_ptr  make_shared Oublier NULL et utiliser null_ptr Capitaliser sur les conteneurs et algorithmes de la STL Intégrer le déplacement dans les membres spéciaux
  • 49. Pour aller plus loin Le standard C++  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3337.pdf Channel 9 : Going Deep (STL, TR1, etc)  http://channel9.msdn.com/Shows/Going+Deep Channel 9 : Going Native  http://channel9.msdn.com/Events/GoingNative/GoingNative-2012 C++ Sessions de la Build 2011  http://channel9.msdn.com/Events/BUILD/BUILD2011?sort=status&direction= asc&t%5B0%5D=c%2B%2B#tab_sortBy_status What's New for Visual C++ in Visual Studio 11 Developer Preview  http://msdn.microsoft.com/en-us/library/hh409293(v=vs.110).aspx Blog équipe VC++  http://blogs.msdn.com/b/vcblog/
  • 50. Pour aller plus loin Chaque semaine, les DevCamps Prochaines sessions des Dev Camps 10 février Open Data - Développer des applications riches avec le protocole Open Live Meeting ALM, Azure, Windows Phone, HTML5, OpenData 2012 Data http://msdn.microsoft.com/fr-fr/devcamp 16 février 2012 Live Meeting Azure series - Développer des applications sociales sur la plateforme Windows Azure 17 février Live Meeting Comprendre le canvas avec Galactic et la librairie three.js 2012 Téléchargement, ressources et 21 février 2012 Live Meeting La production automatisée de code avec CodeFluent Entities toolkits : RdV sur MSDN 2 mars 2012 Live Meeting Comprendre et mettre en oeuvre le toolkit Azure pour Windows Phone 7, iOS et Android http://msdn.microsoft.com/fr-fr/ 6 mars Live Meeting Nuget et ALM 2012 Les offres à connaître 9 mars Live Meeting Kinect - Bien gérer la vie de son capteur 2012 13 mars 90 jours d’essai gratuit de Windows Azure 2012 Live Meeting Sharepoint series - Automatisation des tests www.windowsazure.fr 14 mars 2012 Live Meeting TFS Health Check - vérifier la bonne santé de votre plateforme de développement 15 mars Azure series - Développer pour les téléphones, les tablettes et le cloud Jusqu’à 35% de réduction sur Visual Studio 2012 Live Meeting avec Visual Studio 2010 Pro, avec l’abonnement MSDN 16 mars 2012 Live Meeting Applications METRO design - Désossage en règle d'un template METRO javascript www.visualstudio.fr 20 mars Live Meeting Retour d'expérience LightSwitch, Optimisation de l'accès aux données, 2012 Intégration Silverlight 23 mars Live Meeting OAuth - la clé de l'utilisation des réseaux sociaux dans votre application 2012