Exercice langage C : Analyser des expressions

Analyser les expressions contenues dans le programme suivant :

#include
main()
{
int a;
int b;
int c;
a = 16;
b = 2;
c = 10;
c += a > 0 && a /*
* Que dire de l'expression suivante ? :
* -----------------------------------
*/
a > 30 ? b = 11 : c = 100;
}

#include
§MEVBCBfint main()
{
int a;
int b;
int c;

a = 16;
b = 2;
c = 10;

/*
* 1) on commence par évaluer l'expression
* a > 0 && a * le 1er opérande de l'opérateur ?:.
* Celle-ci est fausse car les expressions
* a > 0 et a * fausse respectivement,
* 2) on évalue donc le 3eme opérande de l'opérateur
* ?:, c'est-à-dire l'expression a/b,
* 3) et enfin on effectue l'affectation.
*/
c += a > 0 && a printf( "c : %d\n", c ); ===> 18

/*
* Que dire de l'expression suivante? :
* ----------------------------------
*/
a > 30 ? b = 11 : c = 100;

/*
* Cette expression provoque une erreur
* à la compilation car le troisième
* opérande de l'opérateur ?: est c
* et non pas c = 100. De ce fait,
* l'expression a > 30 ? b = 11 : c
* est d'abord évaluée. Sa valeur est ensuite utilisée
* comme opérande de gauche de la dernière affectation.
* D'où l'erreur, car cette valeur n'est pas une g-valeur.
*
* On devrait écrire :
*/

a > 30 ? b = 11 : (c = 100);

return 0;
}

Exercice langage C: faire un programme permettant de gérer des fichiers de QCM

Il s'agit de faire un programme permettant de gérer des fichiers de QCM.  Un qcm sera représenté par une

structure du type :
typedef truct qcm {
int numquest;
char quest[256];
char rep1[256];
char rep2[256];
char rep3[256];
char rep4[256];
int solrep;
} TQCM;

Où numquest est le numéro de la question,

quest est la chaine de caractère représentant la question,  rep1 à rep 4 les 4 réponses possibles.

solrep est le numéro de la seule solution à la question

Le programme permet de passer en mode administrateur pour générer des fichiers de qcm, ou en mode utilisateur pour utiliser les qcm. Ces deux modes font l'objet de deux parties différentes. Il est conseillé de commencer par la partie administrateur. Le code de la fonction main vous est donné ci-dessous :

int main (void)
{
char calu;
do { printf("(a) mode administrateur,\n(b) mode utilisateur,\n");
printf("(c) quitter,\nvotre choix : ");
scanf(" %c", &calu);
switch(calu)
{ case 'a': gestion_admin();
calu = 'c';
break;
case 'b': gestion_util();
calu = 'c';
break;
case 'c': printf("fin du programme \n\n");
break;
default : printf("\nmauvaise saisie recommencer !!\n");
}
} while( calu !='c');
return 0;
}

6) Faire la fonction menu de prototype char menu_admin(void) qui présente les choix suivants : menu administrateur :

(a) consulter un fichier qcm,

(b) créer un fichier qcm,

(c) maintenance d'un fichier,

(d) quitter

Lit le caractère saisi au clavier et le retourne à la fonction appelante.

7) Faire la fonction void gestion_admin() qui gère les fonctionnalités du mode administrateur.

Nota : La maintenance du fichier permettant la modification des questions ne sera pas mise en œuvre. Il n'y aura pas de gestion automatisée du numéro des questions dans le fichier.

/* PROGRAMME QCM */
#include
#include
#define MLIGNE 256
#define MNAME 100
struct qcm {
int numquest;
char quest[MLIGNE];
char rep1[MLIGNE];
char rep2[MLIGNE];
char rep3[MLIGNE];
char rep4[MLIGNE];
int solrep;
};
typedef struct qcm TQCM;
/***** PARTIE ADMINISTRATEUR *******/
char menu_admin(void);
/* menu administrateur :
(a) consulter un fichier qcm,
(b) créer un fichier qcm,
(c) maintenance d'un fichier,
(d) quitter */
/* On supposera que l'index numquest de la question dans un fichier est unique.
** On ne traitera pas la maintenance des fichiers (modification d'une question dans un
fichier) */
void gestion_admin(); /* mode administrateur, gestion des fonctionnalités de
l'administrateur */

Exercice langage C: L'ouverture d'un fichier en lecture

Cet exercice a pour but de vérifier les points techniques suivants :

• L'ouverture d'un fichier en lecture
• Tester si un fichier est ouvert (en particulier si vous avez les droits de lecture sur le fichier)
• Parcourir dans son intégralité un fichier
• Fermer le fichier une fois la lecture terminée

Travail à Faire:

Ecrire un programme qui lit le fichier example.txt définit dans l'exemple précédent et affiche son contenu :
Vous devriez obtenir :

Exercices Gratuit!

Voici un programme illustrant l'écriture dans un fichier

#include
#include
#include

int main () {
std::string line;
char * filename = "example.txt";
std::ifstream myfile (filename, std::ios::in);
if (myfile.is_open())
{
while (! myfile.eof() )
{
getline (myfile,line);
std::cout line std::endl;
}
myfile.close();
}

else std::cout "Erreur à l'ouverture du fichier " filename std::endl;;

return 0;
}

Exercice langage C : Ecrire une commande qui simule une calculatrice

Objectif :

Travailler avec les Procédures et Fonctions

Travail à Faire :

Ecrire une commande qui simule une calculatrice réalisant les opérations suivantes:

addition, soustraction, multiplication, modulo, division, entière et  division réelle.

if ($#argv == 3) then
switch ($argv[2])
case +:
@ e = $argv[1] + $argv[3]
breaksw
case -:
@ e = $1 - $3
breksw
case x:
@ e = $1 * $3
breaksw
case /:
@ e = $1 / $3
breaksw
case %:
@ e = $1 % $3
breaksw
case ::
@ a = $1 / $3
@ b = $1 % $3
@ c = $b * 1000
@ d = $c / $3
if ($d 0) @ d = $d * -1
set e = ${a},${d}
breaksw
endsw
echo $e
endif

Exercice langage C : Les valeurs des variables

1.

(*2) Soit le code suivant :

int i = 0, j = 5, somme = 20;

if (j && (i = somme / j) ) somme = 10;

else somme = 30;

Donnez les valeurs des variables après l’exécution de ce programme.

2.

(*3) La fonctionstrcpy permet de copier une chaine de caractères dans une autre, existante.

Voici son prototype :

char

*strcpy ( char *destination, char *source);.

Écrivez cette fonctionsans utiliser de tableaux ni d’opérateurs[] (uniquement des pointeurs et des accès pointeurs).

3.

Dans le code suivant :

int i=0, j=0;

j = ++i;

Que vaut la variablej après l’instruction d’affectation?

1.

Soit erne, un tableau de 10 entiers. Donnez l’instruction permettant de saisir au clavier le 3e
entier.
Réponse : Soit
scanf("%d", &erne[2]) ; ou bien
scanf("%d", erne + 2) ;

2.

(*2) Pourquoi doit-on placer un ’&’ devant la variable ime dans le code suivant :
int ime ;
scanf("%d", &ime) ;
Réponse : La fonction scanf permet de lire des octets à partir du ?chier stdin, habituellement relié au clavier, de les convertir éventuellement selon le format indiqué (ici %d, pour
une conversion en entier, de caractères numériques en base 10) et de stocker le résultat
de cette conversion dans une variable.
En langage C, « stocker dans une variable » s’exprime en utilisant l’opérateur &.

3.

Que vaut la variable ernet à la ?n du code suivant ?
On rappelle que x += y est équivalent à x = x + Y et que de manière générale x op = y
est équivalent à x = x op y.
int ernet = 100 ;
ernet += 5 ;
ernet *= 10 ;
ernet /= 15 ;
ernet %= 4 ;

Exercice langage C: Figures en mode texte

1. Ecrivez un programme qui affiche les valeurs 1 à 9 en ligne, à l'aide d'une boucle for: 123456789
2. Modifiez le programme pour qu'il affiche 9 lignes similaires, à l'aide de 2 boucles for: 123456789 123456789 . . . 123456789
3. Comment modifier le programme pour qu'il affiche un triangle ? 1 12 123 1234 12345 123456 1234567 12345678 123456789
4. Modifiez une dernière fois votre programme, pour qu'il affiche une pyramide inversée: 1 12 123 1234 12345 123456 1234567 12345678 123456789

L'affichage d'une ligne se fait à l'aide d'une simple boucle for. Pour afficher plusieurs lignes, il faudra imbriquer 2 boucles for.

Pour le triangle, la longueur d'une ligne est fonction du numéro de ligne. Donc, la condition d'arrêt de la boucle écrivant une ligne dépendra du compteur de la boucle parent (j).

Pour la pyramide inversée, il suffit de rajouter un nombre variable d'espaces avant les nombres.

#include
using namespace std;
int main(int argc, char **argv)
{
// 1.
for (int i=1; icout cout // 2.
for (int j=1; jfor (int i=1; icout cout }
cout // 3.
for (int j=1; jfor (int i=1; icout cout }
cout // 4.
for (int j=1; jfor (int i=1; icout for (int i=1; icout cout }
cout return 0;
}

Exercice langage C: Triangle creux

Travail à Faire:
 

Écrivez une fonction qui affiche un triangle isocèle ``creux'' à l'aide des caractères / , \ et _ :

Le nombre de lignes sera passé en paramètre. Attention, pour afficher le caractère \ , il faut le répéter deux fois. Exemple: cout affiche un seul |.

void triangle(int lignes)
{
for (int i=0; ifor (int j=lignes; j>i; j--)
cout cout if (i for (int j=0; jcout else
for (int j=0; jcout cout }
}

Exercice langage C : Fonction Triangle Pascal

Il y a plusieurs di?cult´es, la moindre n’´etant pas de “centrer” les lignes.
/* Triangle de Pascal */
#include
main(){
int n, i, c, j;
printf("Bonjour, jusqu’a quelle ligne voulez-vous aller : ");
scanf("%i", &n);
for (i=0; i// On ajoute des espaces pour centrer
for(j=1; jfor(j=1; j// On calcule chaque case
c=1; printf("%6i", c);
for(j=1; jc = c*(i-j+1)/j; //Correct
//c = (i-j+1)/j*c; //La, c’est faux !
printf("%6i", c);
}
// On va a la ligne !!
printf("\n");
}
}

Exercice langage C : Les Suites et les Séries

a)
#include
using namespace std;
int main(int argc, char **argv)
{
float U = 1;
cout for (int n = 1; n U = U / n;
cout }
return 0;
}
b)
#include
using namespace std;
int main(int argc, char **argv)
{
float U = 1;
float V = U;
cout for (int n = 1; n U = U / n;
V = V + U;
cout cout }
return 0;
}

Exercice langage C : Primarité d'un entier

Cet exercice a pour but de vérifier les points techniques suivants :

• Utilisation d'un while de difficulté moyenne.
• Etude d'un algorithme usuel assez difficile : Primarité d'un entier.
• Modélisation d'un problème issu des mathématiques.

Travail à Faire :

Ecrire un programme qui demande de saisir un entier et qui indique si cet entier est premier ou non.

#include
using namespace std;
int main()
{
int n;
bool premier=true;
int d=2;
cout"Veuillez saisir un entier : ";cin>>n;
if(n1)premier=false;
else
{
while(premier==true && d*dn)
if(n%d==0)premier=false; else d=d+1;
}
if(premier)coutn" est premier"endl;
else coutn" n'est pas premier"endl;
return 0;
}

 Exercice langage C : Analyser les Paramètres

Écrire un programme qui analyse les paramètres qui lui sont passés. Ce programme devra être appelé de la manière suivante :

exo11 -a chaine1|-b chaine2|-c chaine3 [-d -e -f] fichier

1. une seule des options -a, -b ou -c doit être spécifiée, suivie d'une chaîne,
2. les options -d, -e, -f sont facultatives. Si aucune d'entre elles n'est indiquée, le programme doit les considérer comme toutes présentes,
3. un nom de fichier doit être spécifié.

On essaiera de rendre l'appel le plus souple possible :

1. exo11 -a chaîne -e fichier
2. exo11 -b chaîne fichier -d -f
3. exo11 -c chaîne fichier -df 
   (regroupement des options -d et -f).

#include
#include
#include
void traitement_option( const unsigned char option );
void usage( char *s );
const unsigned char option_a = 1;
const unsigned char option_b = 2;
const unsigned char option_c = 4;
const unsigned char option_d = 8;
const unsigned char option_e = 16;
const unsigned char option_f = 32;
unsigned char mask_options = 0;
char *valeur_option = NULL, *fichier = NULL;
char *module;
void bilan_options( void );

§MEVBCBfint main( int argc, char **argv )
{
/* Sauvegarde du nom de l'exécutable. */
module = strdup( *argv );
/* Boucle sur les arguments. */
while( *++argv != NULL )
{
/*
* Est-ce que l'argument commence
* par le caractère '-' ?
*/

if( (*argv)[0] == '-' )
{
/* On analyse les caractères qui suivent. */
for( (*argv)++; **argv; (*argv)++ )
{
switch( **argv )
{
case 'a':
traitement_option( option_a );
break;
case 'b':
traitement_option( option_b );
break;
case 'c':
traitement_option( option_c );
break;
case 'd':
traitement_option( option_d );
break;

case 'e':
traitement_option( option_e );
break;
case 'f':
traitement_option( option_f );
break;
default : usage( module );
}
if ( **argv == 'a' || **argv == 'b' || **argv == 'c' )
{
/*
* La valeur de l'option 'a', 'b' ou 'c' peut
* suivre immédiatement, ou bien être séparée
* de l'option par des blancs.
*/
if( *++*argv != '\0' )
valeur_option = strdup( *argv );
/* Cas où aucune valeur ne suit. */
else if( (*++argv)[0] == '-' )
usage( module );
else
valeur_option = strdup( *argv );
break;
}
}
}

/*
* L'argument ne commence pas
* par le caractère '-'.
*/
else if( fichier != NULL )
usage( module );
else
fichier = strdup( *argv );
}
bilan_options();

printf( "\n\nFin EXO11.\n" );

return 0;
}

§MEVBCBfvoid bilan_options( void )
{
/*
* L'option 'a', 'b', ou 'c' suivie d'une
* chaîne, ainsi qu'un nom de fichier
* doivent être spécifiés.
*/

if( valeur_option == NULL || fichier == NULL )
usage( module );

/*
* Si aucune des options 'd', 'e', 'f'
* n'a été spécifiée, on les considère toutes.
*/

if( ! (mask_options & option_d) &&
! (mask_options & option_e) &&
! (mask_options & option_f) )
mask_options |= option_d + option_e + option_f;
if( mask_options & option_a )
printf( "Option \"a\" fournie avec comme valeur : "
"%s\n", valeur_option );
if( mask_options & option_b )
printf( "Option \"b\" fournie avec comme valeur : "
"%s\n", valeur_option );
if( mask_options & option_c )
printf( "Option \"c\" fournie avec comme valeur : "
"%s\n", valeur_option );
printf( "Option \"d\" %s.\n",
mask_options & option_d ? "active" : "inactive" );
printf( "Option \"e\" %s.\n",
mask_options & option_e ? "active" : "inactive" );
printf( "Option \"f\" %s.\n",
mask_options & option_f ? "active" : "inactive" );

printf( "fichier indiqué : %s\n", fichier );

return;
}

§MEVBCBfvoid traitement_option( const unsigned char option )
{
/*
* Une seule des options "-a", "-b", "-c"
* doit avoir été spécifiée.
*/

if ( option == option_a ||
option == option_b ||
option == option_c )
if ( valeur_option != NULL )
usage( module );

/*
* On interdit qu'une option
* soit indiquée 2 fois.
*/

if ( mask_options & option )
usage( module );
else
mask_options |= option;

return;
}

§MEVBCBfvoid usage( char *s )
{
printf( "usage : %s -a chaine | -b chaine"
" | -c chaine [-d -e -f] fichier\n", s );
exit(1);
}