Ajout de deux cours de CMP1 supplémentaire (les deux derniers ?)

cmp/20120202.tex

@@ -0,0 +1,123 @@
+\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.

cmp/20120203.tex

@@ -0,0 +1,109 @@
+\chapter{Name, scope and bindings}
+
+\url{http://lrde.epita.fr/~akim/ccmp/lecture-notes/slides/ccmp/names.pdf}
+
+\section{Bindings}
+
+\subsection{Vocabulaire}
+
+\paragraph{Nom/Name/Symbol~:} chaine de caractère, lisible par l'être humain
+servant à placer des étiquettes sur quelque chose.
+
+\paragraph{Référence~:} mécanisme permettant d'accéder à une case mémoire.\\
+
+Donnée, quantitée, que l'on peut référencé par une référence ou une
+adresse. Cela peut être une variable, pas vraiment un type, pas de fonction,
+mais son code oui, pas de namespace.
+
+
+\paragraph{Identifiant~:} généralement des caractères alphanumériques ou
+l'underscore. Généralement, la première lettre est une minuscule et n'est pas
+un chiffre qui serait un sel syntaxique. Il n'y a pas d'espaces, sauf en Algol
+60 ou en FORTRAN.
+
+Dans certain langage, il y a des limitations sur la taille des identifiants~:
+le FORTRAN original était limité à des identifiants de 6 caractères.
+
+Certains langages sont insensible à la case comme l'Ada.
+
+\subsection{}
+
+\paragraph{Durée de vie~:} Temps entre le moment où l'objet est créée et est
+détruit. Lié à l'exécution.
+
+Dans certain langage comme Pascal, cette notion est lié à la portée, mais
+généralement, c'est différent.
+
+\paragraph{Portée~:} lié au code source, pas vraiment à l'éxécution. L'endroit
+où on peut dire qu'à un endroit particulier, tel nom est associé à telle
+variable.
+
+\subparagraph{Portée statique~:} quand cela peut être calulé à la
+compilation. Dans la plupart des languages (\verb+my+ en Perl, C, Tiger,
+Scheme, \ldots)
+
+Cela permet d'effectuer un typage statique et autorise le typage fort.
+
+C'est donc plus rapide, sûr et propre.
+
+
+\subparagraph{Portée dynamique~:} lorsque cela dépend d'appels
+de fonctions et autres.
+
+Dans la plupart des langage de script (Perl \verb+local+, shell, \TeX (voir la
+slide 14 pour un exemple de code \TeX~!))
+
+Concrètement, on a un dictonnaire de variable référençant toutes les variables
+déjà rencontrée.
+
+\subparagraph{Utilité~:} modularité pour découper le code en morceaux.
+Il n'y en a pas en assembleur.
+
+Dans les systèmes de fichiers, cela correspond aux répertoires.
+
+Lorsque l'on a pas de portée, les noms ont une influence globale, c'est assez
+difficile à gérer, puisqu'il faurait alors des identifiants ayant des noms
+uniques.\\
+
+En interdisant la récurence, on peut se passer de pile d'appel.
+
+\paragraph{Espaces de nom (!= namespaces)~:} par exemple, dans Tiger, on a 3
+espaces de nom~: types, fonctions et variables.
+
+En C, il y a deux espaces de noms~: un pour les types et un pour les fonctions
+et les variables, car on peut avoir une variable qui est une fonction (pointeur
+sur fonction).
+
+
+\paragraph{Moments de liaison (Binding Time)~:} définit à quel moment une
+certaine étape est réalisée.
+
+Plus on fait la liaison tôt, moins le code est flexible, mais plus c'est
+efficasse, mais à l'inverse plus on le fait tard, plus c'est réalisé tard, plus
+c'est flexible, mais c'est moins efficasse.
+
+Un bon compromis serait sans doute Java ou C\# grâce à l'utilisation de machine
+virtuelle qui permet l'introspection ou la compilation à la volée.
+
+Dans Tiger, on fait un certain nombre de liaison~:
+\begin{itemize}
+  \item Andrew Apple a définit les mots-clefs.
+  \item Lorsque l'on programme, on définit les indentifiants
+  \item À la compilation, on définit les types, le code des fonctions, \ldots
+  \item À l'exécution, on lie les adresses des tableaux (appel à malloc), et
+    aux records.
+\end{itemize}
+Tout ce qui est avant l'exécution est donc la partie statique, après, c'est la
+partie dynamique.
+
+
+\section{Table de symboles}
+
+Cas simple sans portée~: avec tableau associatif~; implémentation très simple~:
+\verb+put+ et \verb+get+.\\
+
+Lorsque l'on ajoute la portée, on a besoin de fonctions ou méthodes
+\verb+scope_begin ()+ et \verb+scope_end ()+. On pourrait utiliser
+\verb+std::stack+, mais si l'on peut référencer un élément d'un autre scope, on
+va avoir des problèmes car c'est compliqué de revenir dans les états
+d'avant. Le contener \verb+std::slist+ est du coup plus adapté.