ROUVREAU Vincent
--- a/3-Operators/1-Intro.ipynb
+++ b/3-Operators/1-Intro.ipynb
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "C++ provides the way to mimic this behaviour with **operator overloading**. This is a very powerful conceit, but also one that should be approached with some care...\n",
--- a/3-Operators/2-Comparison.ipynb
+++ b/3-Operators/2-Comparison.ipynb
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "[Examples](https://www.modernescpp.com/index.php/c-20-more-details-to-the-spaceship-operator)  on [the](https://devblogs.microsoft.com/cppblog/simplify-your-code-with-rocket-science-c20s-spaceship-operator/) Web often show the defaulting of a comparison used directly upon the spaceship operator, which is something I will have to investigate when I upgrade to C++ 20 as it seems at first sight rather dangerous to me (see the `Rational` example, where even the default `operator==` is unlikely to be what we want)."
--- a/3-Operators/4-CanonicalForm.ipynb
+++ b/3-Operators/4-CanonicalForm.ipynb
   "cell_type": "markdown",
   "metadata": {},
   "source": [
+    "```txt\n",
    "** Error in `./prog.exe': double free or corruption (fasttop): 0x0000000001532da0 **\n",
+    "```\n",
    "\n",
-    "So what's the deal? The default operator copies all the data attributes from `v1` to `v2`... which here amounts only to the `array_` pointer. But it really copies that: the pointer, and not the data pointed by this pointer. So in fine v1 and v2 points to the same area of memory, and the issue is that we attempt to free the same memory twice.\n",
--- a/3-Operators/5-Functors.ipynb
+++ b/3-Operators/5-Functors.ipynb
   "source": [
    "## What is a functor?\n",
    "\n",
-    "We can provide a class with an operator `operator()` that allows to give its objects a function behavior. In other words: if you write an expression in which an object is used as if it were a function, it is its execution operator that is invoked. \n",
+    "We can provide a class with an `operator()` that allows to give its objects a function behavior. In other words: if you write an expression in which an object is used as if it were a function, it is its execution operator that is invoked. \n",
    "\n",
    "We can also see these *functional objects*, or *functors*, as functions to which we would have added state parameters from one call to another.\n",
    "\n",
-    "The return type is not constrained and might be defined as you wish in the class (`double` is used here):"
+    "The return type and the arguments are not constrained and might be defined as you wish in the class (`int` is used here for return type, and an `int` is required as argument):"