Chapitres traités    Fonctions mathématiques simples Nombre premier Copie de chaîne Calcul de la longueur d'une chaîne Concatenation de deux chaînes Suppression d'une partie de chaîne Récupération d'une partie de chaîne Insertion d'une chaîne dans une autre Retrouver le jour de la semaine d'une date quelconque Recherche d'une suite de diviseurs dans un nombre Saisie au clavier Arguments en ligne de commande

Fonctions mathématiques simples

Vous allez mettre en œuvre un petit programme qui permet de tester trois fonctions très réduites :

1. La fonction impaire qui permet de déterminer si une valeur est impaire.
2. La fonction paire qui permet de déterminer si une valeur est paire.
3. La fonction absolue qui retourne la valeur absolue d'un nombre entier.

Pour chacune de ces trois fonctions, il s'agit de déterminer :

1. Le nombre et le type de paramètre.
2. S'il existe une valeur de retour, et qu'elle est son type.
3. Si c'est une fonction inline.

A partir du scénario proposé ci-contre, utilisez les fonctions adaptées suivant le cas demandé.

Nombre premier

Nous allons reprendre le TP sur la recherche du nombre premier. Toutefois, cette fois-ci, vous allez fabriquer une fonction que vous appelerez premier qui renvois une valeur booléenne suivant le résultat du nombre à rechercher passé en argument. Les affichages et la saisie devra se faire à l'extérieur de cette fonction. Vous pouvez vous servir du codage déjà réalisé lors du TP sur les instructions.

Pour en savoir plus sur le sujet de TP sur la recherche du nombre premier

Copie du contenu d'une chaîne de caractères vers une autre

Pour cet exercice, vous utiliserez le debbuger pour réaliser le suivi du contenu des variables utilisées en positionnant un point d'arrêt sur la dernière ligne du programme (celle comportant l'instruction de retour).

Pour ce programme, vous allez mettre en œuvre :

1. une fonction qui copie le contenu d'une chaîne vers une autre,
2. ainsi qu'une deuxième fonction qui permet de mettre en minuscule toutes les lettres d'une chaîne de caractères.

Pour chacune de ces fonctions, il s'agit de déterminer :

1. Le nombre et le type de paramètre en prenant bien soin de déterminer le type de passage au niveau de la déclaration.
2. S'il existe une valeur de retour, et qu'elle est son type.
3. Si c'est une fonction inline.

Dans le programme principal, et afin de tester ces deux fonctions, vous allez déclarer deux chaînes de caractères :

1. La première se nomme invite et comporte le message suivant « BIENVENUE A TOUS ».
2. La deuxième se nomme message.

Attention : réfléchissez bien à la déclaration la plus adaptée pour chacune de ces chaînes de caractères.

Le but du programme sera dans un premier temps de copier le contenu de la chaîne invite pour remplir la chaîne message. Une fois que cette opération est réalisée, vous devez ensuite placer toutes les lettres de message en minuscule.

En fait, avec les environnements du C++ sont livrées un certain nombre de bibliothèques qui disposent de fonctions bien utiles. C'est notamment le cas d'une bibliothèque qui gère l'ensemble des traitements sur les chaînes de caractères. Pour cela, il est nécessaire d'inclure les déclarations des fonctions que se situent dans le fichier en-tête <string.h>. La fonction qui s'occupe de la copie d'une chaîne vers une autre s'appelle strcpy dont voici la signature :

char *strcpy(char *s1, const char *s2);

Utiliser cette fonction dans votre programme à la place de la fonction que vous venez de construire et tester le résultat. Attention toutefois à la signature proposée. Elle vous indique comment utiliser correctement votre fonction.

Calcul de la longueur d'une chaîne de caractères

Nous allons reprendre tous les traitements sur les chaînes de caractères que nous avons déjà réalisés durant les TP sur les types composés pour en faire des fonctions. Vous allez donc commencer par le calcul de la longueur d'une chaîne et proposer la fonction correspondante. Votre programme principal devra faire appel à cette fonction pour résoudre le problème demandé. Je vous rappelle le sujet.

Vous allez mettre en oeuvre un petit programme qui permet de calculer la longueur d'une chaîne de caractères saisie à partir du clavier. Cette chaîne devra être relativement simple et ne pas comporter d'espace (problème avec l'objet cin).

Dans la bibliothèque délivrée sur le traitement des chaînes de caractères, il existe une fonction qui réalise la même chose. Elle s'appelle strlen dont voici la signature :

int strlen(const char *s);

Utiliser cette fonction dans votre programme à la place de la fonction que vous venez de construire et tester le résultat.

Concaténation de deux chaînes de caractères

Réaliser une fonction qui permet de cancaténer deux chaînes de caractères. Votre programme principal devra faire appel à cette fonction pour résoudre le problème demandé. Je vous rappelle le sujet.

A partir de deux chaînes de caractères saisies au clavier, vous allez concaténer ces deux chaînes pour en faire une seule. La concaténation consiste à fusionner les deux chaînes, l'une à la suite de l'autre pour en faire une troisième.

Dans la bibliothèque délivrée sur le traitement des chaînes de caractères, il existe une fonction qui réalise la même chose. Elle s'appelle strcat dont voici la signature :

char *strcat(char *s1, const char *s2);

Utiliser cette fonction dans votre programme à la place de la fonction que vous venez de construire et tester le résultat.

Suppression d'une partie de chaîne

Réaliser une fonction qui permet de supprimer une partie d'une chaîne de caractères. Votre programme principal devra faire appel à cette fonction pour résoudre le problème demandé. Je vous rappelle le sujet.

A partir d'une chaîne de caractères saisie au clavier, vous allez supprimer une partie de cette chaîne en demandant la position du premier caractère à effacer ainsi que le nombre de caractères à effacer à partir de cette position.

Récupération d'une partie de chaîne

Réaliser une fonction qui permet de récupérer une partie de chaîne de caractères. Votre programme principal devra faire appel à cette fonction pour résoudre le problème demandé. Je vous rappelle le sujet.

A partir d'une chaîne de caractères saisie au clavier, vous allez récupérer une partie de cette chaîne en demandant la position du premier caractère à récupérer ainsi que le nombre de caractères à récupérer à partir de cette position.

Insertion d'une chaîne dans une autre

Réaliser une fonction qui permet d'insérer une chaîne dans une autre. Votre programme principal devra faire appel à cette fonction pour résoudre le problème demandé. Je vous rappelle le sujet.

A partir d'une chaîne de caractères saisie au clavier, vous allez insérer une autre chaîne de caractères (également saisie au clavier) en précisant la position désirée sur la première chaîne de caractères.

Retrouver le jour de la semaine d'une date quelconque

Nous allons reprendre le programme sur le calcul du jour de la semaine d'une date spécifiée par l'opérateur. Je rappelle ci dessous le source que nous avions mis au point :

#include <iostream.h>

// Déclaration des différents types et variables nécessaires à la gestion des dates
enum JourSemaine {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche};
const char* TexteJour[7] = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"};
enum Mois {Janvier, Fevrier, Mars, Avril, Mai, Juin, Juillet, Aout, Septembre, Octobre, Novembre, Decembre};
const char* TexteMois[12] = {"Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"};
const unsigned JoursDansMois[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

// Déclaration de la structure Date
struct Date 
{
   JourSemaine jourSemaine;
   unsigned jourDuMois, joursDansAnnee;
   Mois mois;
   int annee;
};


// Début du programme principal
int main() 
{
   char saisie[12];
   unsigned jours;
   
   /**********************************************************************************
   * Récupération et affichage de la date du jour
   ***********************************************************************************/ 
   Date dateDuJour;
   cout << "Saisie de la date du jour" << endl;
   cout << "--------------------------"  << endl;
   
   // Saisie du jour de la semaine sous forme de chaîne de caractères 
   cout << "Jour de la semaine (Lundi ... Dimanche) ? " <<endl;
   cin >> saisie;
   
   // Retrouver le jour de la semaine
   for (JourSemaine jour=Lundi; jour<=Dimanche; jour = (JourSemaine)(jour + 1))
      if (saisie[0]==TexteJour[jour][0] && saisie[1]==TexteJour[jour][1]) {
         dateDuJour.jourSemaine = jour;
         break;
      }
   
   // Saisie du jour du mois sous forme d'entier non signé
   cout << "Jour du mois (1..31) ? " << endl;
   cin >> dateDuJour.jourDuMois;
   
   // Saisie du mois en cours sour forme de chaîne de caractères
   cout << "Mois (Janvier...Décembre) ? " << endl;
   cin >> saisie;
   
   // Retrouver le mois
   for (Mois mois=Janvier; mois<=Decembre; mois = (Mois)(mois + 1))
      if (saisie[0]==TexteMois[mois][0] 
            && saisie[1]==TexteMois[mois][1]
            && saisie[2]==TexteMois[mois][2]
            && saisie[3]==TexteMois[mois][3]) 
      {
         dateDuJour.mois = mois;
         break;
      }
   
   // Saisie de l'année en cours sous forme d'entier
   cout << "Année ? " << endl;
   cin >> dateDuJour.annee;
   
   // Calcul des jours déjà fait au cours de l'année
   jours = 0;
   for (Mois mois=Janvier; mois<dateDuJour.mois; mois = (Mois)(mois + 1))
      jours+=JoursDansMois[mois];
   dateDuJour.joursDansAnnee = jours+dateDuJour.jourDuMois; 
   //................... en tenant compte des années bissextiles
   if (((2000-dateDuJour.annee)%4)==0 && dateDuJour.mois>Fevrier) dateDuJour.joursDansAnnee++;
   
   // Affichage de la date complète
   cout << "La date est : ";
   cout << TexteJour[dateDuJour.jourSemaine] << ' ';
   cout << dateDuJour.jourDuMois << ' ';
   cout << TexteMois[dateDuJour.mois] << ' ';
   cout << dateDuJour.annee << endl;
   cout << "Jours déjà fait dans l'année : " << dateDuJour.joursDansAnnee << endl << endl << endl;
   
   /**********************************************************************************
   * Récupération et affichage de la date à traiter et affichage du jour de la semaine
   ***********************************************************************************/ 
   Date date;
   cout << "Saisie de la date à calculer" << endl;
   cout << "-----------------------------"  << endl;
      
   // Saisie du jour du mois sous forme d'entier non signé
   cout << "Jour du mois (1..31) ? " << endl;
   cin >> date.jourDuMois;
   
   // Saisie du mois sous forme de chaîne de caractères
   cout << "Mois (Janvier...Décembre) ? " << endl;
   cin >> saisie;
   
   // Retrouver le mois de la date à rechercher
   for (Mois mois=Janvier; mois<=Decembre; mois = (Mois)(mois + 1))
      if (saisie[0]==TexteMois[mois][0] 
            && saisie[1]==TexteMois[mois][1]
            && saisie[2]==TexteMois[mois][2]
            && saisie[3]==TexteMois[mois][3]) 
      {
         date.mois = mois;
         break;
      }
   
   // Saisie de l'année
   cout << "Année ? " << endl;
   cin >> date.annee;
   
   // Calcul des jours déjà fait au cours de l'année de la date à rechercher
   jours = 0;
   for (Mois mois=Janvier; mois<date.mois; mois = (Mois)(mois + 1))
      jours+=JoursDansMois[mois];
   date.joursDansAnnee = jours+date.jourDuMois; 
   //................... en tenant compte des années bissextiles
   if (((2000-date.annee)%4)==0 && date.mois>Fevrier) date.joursDansAnnee++;
   
   // Calcul du jour de la semaine de la date à calculer par rapport à la date du jour.
   jours = 0;
   if (date.annee<=dateDuJour.annee) {
      for (int annee = date.annee; annee<dateDuJour.annee; annee++)  
         jours += (annee-2000)%4 == 0 ? 366 : 365;
      int differenceDeJours = jours - date.joursDansAnnee + dateDuJour.joursDansAnnee;
      int decalageJour = differenceDeJours>0 ? 7-differenceDeJours%7 : -differenceDeJours%7;
      date.jourSemaine = (JourSemaine)((decalageJour+dateDuJour.jourSemaine)%7);
   }
   else {
      for (int annee = dateDuJour.annee; annee<date.annee; annee++)
         jours += (annee-2000)%4 == 0 ? 366 : 365;
      int differenceDeJours = jours + date.joursDansAnnee - dateDuJour.joursDansAnnee;
      date.jourSemaine = (JourSemaine)((differenceDeJours+dateDuJour.jourSemaine)%7);
   }      
   
   // Affichage complet de la date à rechercher
   cout << "La date complète est : ";
   cout << TexteJour[date.jourSemaine] << ' ';
   cout << date.jourDuMois << ' ';
   cout << TexteMois[date.mois] << ' ';
   cout << date.annee << endl;
   cout << "Jours déjà fait dans l'année : " << date.joursDansAnnee << endl;
   
   return 0;
}

Dans ce source, nous voyons que nous répétons un certain nombre de chose pour la mise en place des deux dates. Notamment, nous retrouvons des écritures très similaires, d'une part pour retrouver le mois à partir de la saisie de la chaîne de caractères correspondante, d'autre part pour calculer les jours déjà fait dans l'année, mais également lors de l'affichage de chacune de ces dates. Il paraît donc judicieux de factoriser ces informations sous forme de fonctions spécifiques. Nous allons d'ailleurs en profiter pour créer des fonctions sur chacune des tâches importantes de la gestion de ces dates. Vous allez donc restructurer ce programme (qu'il suffit de copier) afin de tenir compte de ces nouvelles fonctions dont voici la liste :

1. retrouverJourSemaine( ? ) : Cette fonction a pour but de déterminer le champ jourSemaine de la structure Date passée en paramètre par rapport à la chaîne de caractère également passée en paramètre correspondant à la saisie du jour de la semaine réalisée par l'opérateur. Cette saisie est effectuée en dehors de cette fonction.
2. retrouverMois( ? ) : Cette fonction a pour but de déterminer le champ mois de la structure Date passée en paramètre par rapport à la chaîne de caractère également passée en paramètre correspondant à la saisie du mois réalisée par l'opérateur. Cette saisie est effectuée en dehors de cette fonction.
3. joursDejaFait( ? ) : Cette fonction a pour but de déterminer le champ joursDansAnnee de la structure Date passée en paramètre.
4. affichage( ? ) : Cette fonction a pour but d'afficher à l'écran la date passée en paramètre.
5. calculJourSemaine( ? ) : Cette fonction a pour but de calculer le jour de la semaine de la date passée en paramètre, par rapport à une date de référence (date d'aujourd'hui) également passée en paramètre.

Attention : Pour toutes ces fonctions, il est nécessaire de préciser le ou les pramètres éventuels ainsi que le type de retour. Une fois que toutes ces fonctions sont définies, le programme principal n'a plus qu'à les utiliser en passant les arguments requis.

Recherche d'une suite de diviseurs dans un nombre

En reprenant la recherche que nous avons effectué sur les nombres premiers, nous allons faire l'étude inverse, c'est-à-dire rechercher la suite des diviseurs que compose un nombre saisi au clavier. Pour cela vous allez construire les éléments suivants :

1. D'abord une structure dénommée Diviseurs, composée d'une part, d'un tableau de valeurs et d'autre part, du nombre de valeurs que contient effectivement le tableau.
2. D'une fonction dénommée rechercheDiviseurs qui permet de compléter cette structure passée en argument par rapport à un nombre (également passé en argument) qui est la valeur saisie par l'opérateur.

Voici un exemple du résultat attendu :

Saisie au clavier – récupérer une valeur entière issue d'une chaîne de caractères (en option)

En vous aidant de l'étude réalisée lors du TP sur les chaînes, vous allez mettre en œuvre un programme qui permet de récupérer une valeur numérique issue de la saisie au clavier. Ce programme doit surtout assurer le contrôle de la valeur introduite afin de prévenir l'utilisateur lors d'une mauvaise saisie.

Pour réaliser cette opération, vous devez élaborer deux fonctions :

bool chaineInt( const char *chaine, int &entier) ;

Cette fonction permet à partir d'une chaîne passée en paramètre de donner la valeur entière équivalente, si bien entendue, une valeur entière est bien présente dans cette chaîne. Justement, la fonction doit retourner true si une valeur entière a pu être trouvée, et false dans le cas contraire.

int clavierInt( const char *message) ;

Cette fonction doit, à partir d'un message d'invite comme « Introduisez votre valeur : », retourner la valeur entière saisie par l'opérateur. Cette fonction doit se servir de la fonction chaineInt élaborée ci-dessus, et contrôler le résultat afin d'avertir convenablement l'utilisateur d'une mauvaise saisie éventuelle. On doit rester à l'intérieur de cette fonction jusqu'à ce qu'une valeur entière soit correctement saisie.

Arguments en ligne de commande

Cette fois-ci, vous allez mettre en œuvre un programme qui permet de passer des arguments sur la ligne de commande. Ce programme effectue du calcul simple (+, -, *, /) sur des valeurs entières. Il se nomme tout simplement calcul auquel vous devez impérativement passer 3 paramètres ; les deux opérandes ainsi que l'opération représentant le calcul. En tenant compte du scénario ci-contre, il est impératif de contrôler les différents opérandes pour que le calcul puisse effectivement se réaliser.