====== TD : Premiers pas avec C++ ======

===== Première Partie :Installation d'un environnement C++ =====

==== Etape 1 : Installation de l'environnement ====

En vous référant à la [[..:outils|documentation disponible]] sous ce lien et en n'hésitant pas à demander à l'enseignant de vous accompagner, installer un environnement de développement sur votre ordinateur.

==== Etape 2 : Compilation d'un exemple simple de classe C++ ===

En fonction de l'environnement, essayer de créer un projet "console" et ensuite ajouter le code suivant dans ce projet.

  * Fichier ''rational.hpp''\\ <code cpp>
#ifndef rationalHPP
#define rationalHPP

#include<exception>
#include<stdexcept>
#include<iostream>

class rational
{
private:
	long m_numerator;
	long m_denominator;

	template<typename  charT, typename charTraits> 
	friend inline std::basic_ostream<charT, charTraits>& operator << (
			std::basic_ostream<charT, charTraits>& aStream, const rational& aRational);

public:
	rational() : m_numerator(0), m_denominator(1)
	{}
	rational(long theNumerator) : 
		m_numerator(theNumerator), m_denominator(1) 
	{}
	rational(long theNumerator, long theDenominator)
	{
		if (theDenominator == 0)
			throw std::invalid_argument("denominator is 0");
		if (theDenominator < 0)
		{
			theNumerator *= -1;
			theDenominator *= -1;
		}
		m_numerator = theNumerator;
		m_denominator = theDenominator;
	}
	rational(const rational& aRational): 
		m_numerator(aRational.m_numerator), 
		m_denominator(aRational.m_denominator)
	{}

	operator double() const
	{
		return (double)m_numerator / (double)m_denominator;
	}
	rational operator + (const rational& anotherRational) const
	{
		return rational(m_numerator * anotherRational.m_denominator + m_denominator * anotherRational.m_numerator,
			m_denominator * m_numerator);
	}
	rational operator - (const rational& anotherRational) const
	{
		return rational(m_numerator * anotherRational.m_denominator - m_denominator * anotherRational.m_numerator,
			m_denominator * m_numerator);
	}
	rational operator * (const rational& anotherRational) const
	{
		return rational(m_numerator * anotherRational.m_numerator,
			m_denominator * m_numerator);
	}
	rational operator / (const rational& anotherRational) const
	{
		return rational(m_numerator * anotherRational.m_denominator - m_denominator * anotherRational.m_numerator,
			m_denominator * m_numerator);
	}
};

template<typename  charT, typename charTraits>
inline std::basic_ostream<charT, charTraits>& operator << (
	std::basic_ostream<charT, charTraits>& aStream, const rational& aRational)
{
	aStream << aRational.m_numerator;
	if (aRational.m_denominator != 1)
		aStream << "/" << aRational.m_denominator;
	return aStream;
}

#endif
</code>
  * Fichier ''main.cpp''\\ <code cpp>
#include"rational.hpp"

#include<iostream>

int main()
{
	try
	{
		rational valueA = { 1, 0 };
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}
	rational valueA = { 4, 3 };
	rational valueB = { 3, 4 };

	std::cout << "A + B = " << (valueA + valueB) << std::endl;
	std::cout << "A - B = " << (valueA - valueB) << std::endl;
	std::cout << "A * B = " << (valueA * valueB) << std::endl;
	std::cout << "A / B = " << (valueA / valueB) << std::endl;

	std::cout << "4 * B = " << (4 * valueB) << std::endl;
        return 0;
}
</code>

Assurez vous que le projet compile et s'exécute correctement.

<hidden Correction>
Il suffit de vérifier que le programme compile et s'exécute correctement. 
</hidden>

===== Seconde partie : Création d'une classe "Compteur" en C++ =====

==== Question 2.1 ====

Créer un projet "console" vide dans votre environnement de développement.

<hidden Correction>
Cela dépend de votre environnement.  
</hidden>

==== Question 2.2 ====

Ajoutez un fichier ''Counter.h'' ou ''Counter.hpp'' ou ''Counter.hh'' dans votre fichier et introduisez la structure de la classe ''Counter'' dans ce fichier.

<code cpp>
class MyCounter
{
public:
    unsigned counter;
    unsigned max; 
};
</code>

<hidden Correction>
A nouveau, il suffit de créer les deux fichiers. Par contre, il est important de s'assure que le contenu d'un fichier entête (ie. .h, .hh ou .hpp) ne puissent pas être compilé deux fois même s'il est chargé plus d'une fois. Pour ce faire, il est de bonne pratique d'utiliser la structure suivante :
<code cpp>
#ifndef nameHPP
#define nameHPP

// contenu de votre fichier.
#endif  
</code>

où ''name'' correspond au nom de votre fichier, "HPP" pour l'extension '.hpp', "H" pour l'extension '.h', ainsi de suite. 

La première fois que le fichier est chargé par le compilateur, l'identifiant ''nameHPP'' n'est pas défini, on analyse le code situé après la directive ''#ifndef''. La première ligne suivante : ''#define nameHPP'' définit l'identifiant ''nameHPP'' et puis ensuite le contenu du fichier est analysé.

Si on charge une seconde fois le fichier, l'identifiant ''nameHPP'' est défini, donc le contenu situé entre la directive ''#ifndef nameHPP'' et la directive ''#endif'' est ignoré. Cela empêche d'avoir des erreurs liées au fait que l'on charge le fichier d'entête plus d'une fois.

</hidden>

=== Question 2.3 ===

Ajoutez les fonctions membres à votre compteur :

<code cpp>
class MyCounter
{
public:
    
    ...
    
    void increment() {
      counter ++;
      if(counter > max)
        counter = 0;
    }
 
    void reset() {
      counter = 0;
    }
};
</code>

Expliquer ce que font ces fonctions membres.

<hidden Correction>
La première fonction augmente le compteur de un en un tant que la valeur maximale n'est pas atteinte. Si la valeur maximale est atteinte, il recommance à compter à partir de la valeur 0. 

La seconde fonction remet le compteur à 0.
</hidden>

=== Question 2.4 ===

Testez le code avec le programme ''main.cpp'' suivant :

<code cpp>
#include<iostream>
#include "counter.hpp"

void testCounter()
{
  MyCounter counterA;
  counterA.counter = 0;
  counterA.max = 2;

  MyCounter counterB;
  counterB.counter = 0;
  counterB.max = 4;
  
  for(int i = 0; i < 4; i++)
  {
      std::cout << "compteur A: (" << counterA.counter << ", " << counterA.max << ")" << std::endl;
      std::cout << "compteur B: (" << counterB.counter << ", " << counterB.max << ")" << std::endl;
      counterA.increment();
      counterB.increment();
  }
}

int main()
  testCounter();
  return 0;
}
</code>

Expliquer le comportement des compteurs.

<hidden Correction>
Le ''counterA'' a été créé avec ''count'' à 0 et ''max'' à 2.

Le ''counterB'' a été créé avec ''count'' à 0 et ''max'' à 4.

Incrémenter le compteur ''counterA'' va générer la séquence : 0, 1, 2, 0, ...

Incrémenter le compteur ''counterB'' va générer la séquence : 0, 1, 2, 3, ...

</hidden>

===== Troisième partie : Les constructeurs =====

Nous voyons dans le code précédent que nous créons un ''compteur'' et que nous l'initialisation en mettant à jour les valeurs ''counter'' et ''max''.

Cependant, ceci n'est pas optimal pour plusieurs raisons:
  * nous avons un objet qui n'a pas été initialisé du tout. 
  * nous avons un objet qui peut-être partiellement initialisé, seul le champ ''max'' ou le champ ''counter'' a été initialisé,
  * nous avons un objet qui est mal initialisé, par exemple la valeur du chmap ''max'' est inférieur à la valeur du ''counter'', ce qui ne doit jamais se produire.

==== Question 3.1 ==== 

Vérifier le problème de la mauvaise initialisation d'un objet en exécutant le code suivant.

<code cpp>
void createArrayOfCounters()
{
    MyCounter counters[4];
    for(int i = 0, i < 4; i ++)
      std::cout << i << " : " << counters[i].counter << "/" << counters[i].max << std::endl;
}

void main()
{
  createArrayOfCounters();
  return 0;
}
</code>

<hidden Correction>
Vous constatez que les valeurs des champs ''count'' et ''max'' ont des valeurs qui sortent de nul part.
</hidden>

==== Question 3.2 ==== 

Proposer des constructeurs pour les compteurs pour s'assurer que le compteur est bien initialisé.

On proposera au moins deux constructeurs :
  * un constructeur qui met ''counter'' à 0 et ''max'' à une valeur maximale passée en paramètre et strictement supérieure à 0,
  * un constructeur qui met ''counter'' et ''max'' à des valeurs passées en paramètre. Cependant si ''counter'' est supérieur à ''max'' on met ''counter'' à 0. 

=== Question 3.2.1 === 

Ajouter ces constructeurs à votre classe.

<hidden Correction>

Nous ajoutons les deux constructeurs comme suit:
<code cpp>
class MyCounter
{
public:
    int counter;
    int max;
    
    explicit MyCounter(int theMaxValue): count(0), max(theMaxValue) {}
    MyCounter(int theCounter, int theMaxValue): count(theCounter), max(theMaxValue) {}
    
    void increment() {
      counter ++;
      if(counter > max)
        counter = 0;
    }
 
    void reset() {
      counter = 0;
    }
};
</code>

Comme nous ne souhaitons pas une conversion automatique d'un entier en compteur, nous devons mettre ''explicit'' pour empêcher que le compilateur utiliser le constructeur ''MyCounter(int)'' comme constructeur de conversion lui permettant de convertir un entier en un objet de type ''MyCounter''.

</hidden>

=== Question 3.2.2 === 

Modifier la fonction ''testCounter'' pour utiliser ces constructeurs afin de créer et d'initialiser les objets ''counterA'' et ''counterB''.

<hidden Correction>

Le code est simplifier, puisqu'il suffit de passer au constructeur la valeur maximale du compteur, supprimant les initialisations des champs ''counter'' et ''max'' qui ne sont désormais plus nécessaires et souhaitables.

<code cpp>
void testCounter()
{
  MyCounter counterA(2);
  MyCounter counterB(4);
  
  for(int i = 0; i < 4; i++)
  {
      std::cout << "compteur A: (" << counterA.counter << ", " << counterA.max << ")" << std::endl;
      std::cout << "compteur B: (" << counterB.counter << ", " << counterB.max << ")" << std::endl;
      counterA.increment();
      counterB.increment();
  }
}
</hidden>

===== Quatrième partie : Rendre publique/privée des champs et fonctions =====

Nous voyons bien que les champs ''counter'', ''max'' sont des champs qui ne devraient pas pouvoir être modifié accidentellement puisque cela modifie le comportement du compteur. Par exemple, le code suivant conduit à un comportement erratique :

<code cpp>
int main()
{
  MyCounter counterA;
  counterA.counter = 0;
  counterA.max = 10;

  
  for(int i = 0; i < 4; i++)
  {
      std::cout << "compteur A: (" << counterA.counter << ", " << counterA.max << ")" << std::endl;
      counterA.increment();
      counterA.max -= 2;
  }
  return 0;
</code>

Dans ce cas, il faut rendre les champs uniquement accessible en lecture et non pas en lecture et écrire. Pour ce faire, il suffit de :
  * rendre les champs privés (on doit transformer la déclaration de l'objet ''MyCounter'' de ''struct'' en ''class''.
  * définir dans cette classe au moins une section ''public'' et une section ''private'':\\ <code cpp>
    class MyCounter
    {
        private:
          ... // section privée
        public:
          ... // section publique
    };
</code>
  * mettre les champs privés et définir des fonctions pour accéder aux valeurs. Nous appellons ces fonctions des accesseurs. Souvent en lecture elle commence par ''get'' suivit du nom de la variable, en écriture, par ''set'' et le nom de la variable. Ici, nous proposons de définir les fonctions ''getCounter'' et ''getMax'' qui elles seront publiques. 

==== Question 4.1 ====

Modifier votre classe en rendant les champs ''max'' et ''counter'' privés et en déclarant des méthodes d'accès ''getCounter'' et ''getMax''.

<hidden Correction>
Il suffit de déplacer les deux champs ''counter'' et ''max'' dans la section privée ''private'' de la classe et d'ajouter les méthodes ''int getCounter() const'' et ''int getMax() const'' qui retourne une copie du champ ''counter'' et du champ ''max''. On ajoute le mot clé ''const'' pour indiquer que la méthode ne modifie aucun champ de l'objet et donc ne modifie pas l'objet. 

<code cpp>
class MyCounter
{
private:
    int counter;
    int max;
public:    
    explicit MyCounter(int theMaxValue): count(0), max(theMaxValue) {}
    MyCounter(int theCounter, int theMaxValue): count(theCounter), max(theMaxValue) {}
    
    int getCounter() const { return counter; }
    int getMax() const { return max; }

    void increment() {
      counter ++;
      if(counter > max)
        counter = 0;
    }
 
    void reset() {
      counter = 0;
    }
};
</code>
</hidden>

==== Question 4.2 ====

Vérifier que la compilation de la fonction ''testCounter'' génère des erreurs.

<hidden Correction>
Le compilateur indique qu'il n'est pas possible d'accéder aux champs ''counter'' et ''max''.
</hidden>

==== Question 4.3 ====

Modifier la fonction ''testCounter'' pour désormais appeller les méthodes d'accès. Vérifier le bon fonctionnement de la fonction ''testCounter''.

<hidden Correction>

Il suffit de remplacer les accès aux champs ''max'' et ''counter'' par des appels aux méthodes ''getMax()'' et ''getCounter()''.

<code cpp>
void testCounter()
{
  MyCounter counterA(2);
  MyCounter counterB(4);
  
  for(int i = 0; i < 4; i++)
  {
      std::cout << "compteur A: (" << counterA.getCounter() << ", " << counterA.getMax() << ")" << std::endl;
      std::cout << "compteur B: (" << counterB.getCounter() << ", " << counterB.getMax() << ")" << std::endl;
      counterA.increment();
      counterB.increment();
  }
}
</hidden>