Differences

This shows you the differences between two versions of the page.

--- in204:tds:sujets:td5:part1 [2019/10/22 18:26]
bmonsuez [Question n°1.3]
+++ in204:tds:sujets:td5:part1 [2022/11/18 10:48] (current)
@@ Line 30: / Line 30: @@
 <hidden Correction>
+<nodisp 2>
 Pour convertir un nombre en virgule flottante en un nombre complexe, il faut définir de [[in204:cpp:syntax:class:constructor|nouveaux constructeurs]] qui vont prendre un seul argument qui aura pour type le type d'un nombre à virgule flottante.
@@ Line 63: / Line 64: @@
 };
 </code>
 </hidden>
 ==== Question n°1.2=====
@@ Line 94: / Line 94: @@
 };
 </code>
 </hidden>
 ==== Question n°1.3=====
@@ Line 187: / Line 186: @@
     Complex complexB(Polar(), 1.0, 0,52);
 </code>
 </hidden>
@@ Line 193: / Line 191: @@
 Créer une variable globale ayant comme type la classe complexe et ayant pour valeur la valeur imaginaire 1.
+<hidden Correction>
+Pour ce faire, il suffit de définir une variable globale :
+<code cpp>
+const Complex I(0.0, 1.0);
+</code>
+ou sinon :
+<code cpp>
+const Complex I = Complex::from_real_imaginary(0.0, 1.0);
+</code>
+en fonction de l'implantation que vous avez effectué aux questions précédentes.
+Cependant, la difficulté, c'est qu'une variable globale ne peut être définie que dans une seule et unique unité de compilation. Dans ce cas, il suffit d'écrire dans le fichier ''complex.cpp''
+<code cpp>
+// Fichier Complex.cpp
+#include"Complex.hpp"
+const Complex I(0.0, 1.0);
+</code>
+Cependant, dans ce cas, la variable n'est que visible dans l'unité de compilation ''Complex.cpp''. Pour la rendre visible dans les autres unités de compilation, il est nécessaire de déclarer son existence dans le fichier ''Complex.hpp'' pour que les unités de compilation faisant référence aux nombres complexes puissent faire référence à la variable ''I''.
+Nous devons donc ajouter la déclaration suivante :
+<code cpp>
+#ifndef ComplexHPP
+#define ComplexHPP
+...
+class Complex
+{
+...
+};
+...
+extern const Complex I;
+...
+#endif
+</code>
+Une approche permettant de simplifier l'écriture est de définir un identificateur permettant de savoir si le fichier ''Complex.hpp'' est chargé par le fichier ''Complex.cpp'', ie. si c'est l'unité ''Complex.cpp'' qui est en cours de compilation. Dans ce cas, il est possible d'effectuer l'ensemble de la déclaration dans le fichier ''Complex.h'', le fichier ''Complex.cpp'' se contentant de définir un symbole comme par exemple ''complexCPP''
+Le fichier ''Complex.hpp'' a désormais la structure suivante :
+<code cpp>
+#ifndef ComplexHPP
+#define ComplexHPP
+...
+class Complex
+{
+...
+};
+...
+#ifndef complexCPP
+extern const Complex I;
+#else
+const Complex I(0.0, 1.0);
+#endif
+...
+#endif
+</code>
+et le fichier ''Complex.cpp'' :
+<code cpp>
+// Fichier Complex.cpp
+#define complexHPP
+#include"Complex.hpp"
+</code>
+</hidden>
 ==== Question n°1.5=====
@@ Line 201: / Line 275: @@
     Complex complexValue = 3.3 + 5 * I;
 </code>
+<hidden Correction>
+En fait, il est nécessaire de déclarer un opérateur de multiplication par une valeur numérique avant de pouvoir procéder à cette écriture.
+Pour ce faire vous ajouter la déclaration suivante :
+<code cpp>
+class Complex
+{
+    friend Complex operator * (int, const Complex&);
+    friend Complex operator * (double, const Complex&);
+    friend Complex operator * (const Complex&, int);
+    friend Complex operator * (const Complex&, double);
+private:
+...
+};
+inline Complex operator * (int theLeftValue, const Complex& theRightValue)
+{
+    return Complex(theLeftValue * theRightValue.mRealPart,
+        theRightValue.mImaginaryPart);
+}
+inline Complex operator * (const Complex& theLeftValue, int theRightValue)
+{
+    return Complex(theLeftValue.mRealPart * theRightValue,
+        theLeftValue.mImaginaryPart);
+}
+inline Complex operator * (double theLeftValue, const Complex& theRightValue)
+{
+    return Complex(theLeftValue * theRightValue.mRealPart,
+        theRightValue.mImaginaryPart);
+}
+inline Complex operator * (const Complex& theLeftValue, double theRightValue)
+{
+    return Complex(theLeftValue.mRealPart * theRightValue,
+        theLeftValue.mImaginaryPart);
+}
+</code>
+</hidden>
 ===== Question n°2=====
@@ Line 215: / Line 330: @@
 </code>
+<hidden Correction>
+<code cpp>
+	Complex operator + (const Complex& aRightValue) const
+        {
+            Complex result(this);
+            result.mRealPart += aRightValue.mRealPart;
+            result.mImaginaryPart += aRightValue.mImaginaryPart;
+            return result;
+        }
+	Complex operator - (const Complex& aRightValue) const;
+        {
+            Complex result(this);
+            result.mRealPart -= aRightValue.mRealPart;
+            result.mImaginaryPart -= aRightValue.mImaginaryPart;
+            return result;
+        }
+</code>
+</hidden>
 ==== Question n°2.2====
@@ Line 225: / Line 359: @@
 Expliquer la différence avec les opérations précédentes ?
+<hidden Correction>
+<code cpp>
+class Complex
+{
+    ...
+    public:
+	Complex operator + (double aRightValue) const
+        {
+            Complex result(this);
+            result.mRealPart += aRightValue;
+            return result;
+        }
+	Complex operator - (double aRightValue) const;
+        {
+            Complex result(this);
+            result.mRealPart -= aRightValue;
+            return result;
+        }
+</code>
+Ces fonctions calculent l'addition d'un nombre à virgule flottante avec un nombre complexe, cependant, le nombre complexe est à gauche, le nombre à virgule flottante est à droite. Si nous voulons avoir un nombre à virgule flottante à gauche et un nombre complex à droite, il n'est pas possible de définir l'opérateur dans la classe mais en dehors de la classe. Les opérateurs définis dans la classe suppose que le premier argument de l'opéateur est l'objet lui-même.
+<code cpp>
+class Complex
+{
+    friend Complex operator +(double, const Complex&);
+    friend Complex operator -(double, const Complex&);
+    ...
+    public:
+	Complex operator + (double aRightValue) const
+        {
+            Complex result(this);
+            result.mRealPart += aRightValue;
+            return result;
+        }
+	Complex operator - (double aRightValue) const;
+        {
+            Complex result(this);
+            result.mRealPart -= aRightValue;
+            return result;
+        }
+   ...
+};
+Complex operator +(double aLeftValue, const Complex& aRightValue)
+{
+    Complex result(aRightValue);
+    result.mRealPart += aRightValue;
+    return result;
+}
+Complex operator -(double aLeftValue, const Complex& aRightValue)
+{
+    Complex leftValue(aLeftValue, 0.0);
+    return leftValue - aRightValue;
+}
+</code>
+</hidden>
 ==== Question n°2.3 ====
@@ Line 232: / Line 427: @@
 	Complex complexValue = 3.3 + 5 * I;
 </code>
+<hidden Correction>
+Nous pouvons désormais définir des types complexes et effectué des calculs sur ces types complexes.
+Ainsi il sera possible de définir :
+<code cpp>
+Complex I(0, 1);
+Complex complexValue = 3.3 + I;
+</code>
+Cependant, le code suivant est ambiguë :
+<code cpp>
+	Complex complexValue = 3.3 + 5 * I;
+</code>
+En effet, il faudrait être mesure de faire une multiplication entre un nombre entier ou un nombre à virgule flottante et un nombre complexe. Nous verrons comment faire pour effectuer ce type conversion à la fin de l'exercice.
+</hidden>
 ==== Question n°2.4 ====
@@ Line 251: / Line 468: @@
 ==== Question n°3.2 ====
-Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.
+Proposer une surcharge des opérations * et /. Implanter ces dernières et tester.
 <code cpp>
@@ Line 258: / Line 475: @@
 </code>
+<hidden Correction>
+<code cpp>
+	Complex operator * (const Complex& aRightValue) const
+        {
+            return Complex(
+                mRealPart * aRightValue.mRealPart - mImaginaryPart * aRighValue.mImaginaryPart,
+                mRealPart * aRightValue.mImaginaryPart + mImaginaryPart * aRightValue.mRealPart);
+        }
+	Complex operator / (const Complex& aRightValue) const
+        {
+            double squareNorm = aRightValue.mRealPart * aRightValue.mRealPart
+                + aRightValue.mImaginaryPart * aRightValue.mImaginaryPart;
+            return *this *
+                Complex(aRighValue.mRealPart / squareNorm,
+                    - aRightValue.mImaginaryPart / squareNorm);
+        }
+</code>
+</hidden>
 ==== Question n°3.3 (optionnel) ====
-Proposer une surcharge des opérations + et –. Implanter ces dernières et tester.
+Proposer une surcharge des opérations '*=' et '/='. Implanter ces dernières et tester.
 <code cpp>

Cours

User Tools

Site Tools

Differences

Page Tools