\chapter{C++ 2011}

Nouveau standard depuis 2011, la dernière révision était la première de 1998.

Nécessite GCC-4.6 ou clang 3.0.

Le premier vrai compilateur C++ est G++, avant il n'y en avait pas vraiment.
Clang, démarré il y a une 10aine d'année, autour de LLVM. Clang est plus
moderne, écrit en C++, de manière modulaire. Il donne généralement des
meilleurs erreurs que G++. Il n'implémente cependant pas encore toutes les
fonctionnalités du standard.

\section{nullptr}

Il s'agit d'une constante.

\begin{verbatim}
void f(int);
void f(void*);
\end{verbatim}

On a une ambiguité lorsque l'on appelait \verb+f(0)+.


\section{range-based for}

\begin{verbatim}
for (const int& v : l)
  std::cout << v << std::endl;
\end{verbatim}

Avant il y avait bien la macro \verb+BOOST_FOREACH+, mais elle produisait
évidemment des messages d'erreurs très peu compréhensible !


\section{Les chevrons fermants dans les templates}

\begin{verbatim}
std::vector<std::vector<int> > matrix
                            ^
\end{verbatim}

Dans le nouveau standard, il est donc maintenant possible de coller les deux
\verb+>>+. Il s'agissait d'un problème de priorité des opérateurs.

\section{Code compilé dans notre dos~!}

Le code suivant~:
\begin{verbatim}
struct A
{
};
\end{verbatim}

Génére le code suivant pour le compilateur~:

\begin{lstlisting}
struct A
{
  A ();
  A (const A&);
  ~A ();
  A& operator= (const A&);
};
\end{lstlisting}

C'est pour que les classes en C++ ressemblent par défaut au C.

Par moment, il est parfois nécessaire de désactiver (par exemple on ne veut pas
autoriser la copie d'un singleton).

Pour supprimer explicitement une méthode, on fait de cette manière~:
\begin{lstlisting}
struct A
{
  A (const A&) = delete;
  A& operator= (const A&) = delete;
};
\end{lstlisting}

Également, lorsque l'on crée un constructeur avec un argument, le constructeur
sans argument est automatiquement désactivé. Pour le réactiver, on fait~:

\begin{lstlisting}
struct A
{
  A (int i);
  A () = default;
};
\end{lstlisting}


\paragraph{Design Pattern~:} une recette générale pour résoudre des problèmes
généraux.

\section{Genre d'inférence de type}

Si l'on veut instancier la classe \verb+VeryLongType+ de façon dynamique :

\begin{lstlisting}
VeryLongType* v = new VeryLongType(...);
^^^^^^^^^^^^^
     auto     v = new VeryLongType(...);
\end{lstlisting}

Ces deux constructions fonctionnent en C++2011. En utilisant \verb+auto+, le
compilateur va déduire le type.


\paragraph{Changement de auto} avant, \verb+auto+ permettaient de
préciser où placer une variable (avec \verb+register+)~: dans un registre ou
dans la mémoire. Mais ce n'est plus utile maintenant avec le grand nombre de
registre des processeurs~; et surtout on a de nombreux algos qui sont très
performants pour déterminer le meilleurs endroit.


\chapter{AST}

\paragraph{Tips pour TC2~:} utiliser la commande \verb+patch+ pour appliquer
les patchs. Mais cette année, on pourrait faire un merge avec un dépôt public.

La construction d'objets se déroule de la classe la plus supérieure à la classe
de base (dans le cas d'héritage). La destruction se fait dans l'autre sens.