|
Acceuil
Avant de commencer
----- Un peu d'exercice ? -----
Débutant // Intermédiaire // Confirmé
Projet 001
Projet 002
Projet 003
Projet 004
Liens utiles
Me contacter
Le livre d'or
Activité du site
|
Je Dev alors Tu Dev ;-)
Bonjour,
j'ai volontairement décidé de ne pas copier coller les sources, mais de faire des copies d'écrans pour vous inciter à coder.
Faite un clic droit sur l'image et sur le bouton afficher l'image, elle sera plus lisible.
-----------------------------------------------
Exercice 31
Speudo Aléatoire
Les indices :
la commande atol(var); sert à convertir vers un nombre int.
créez un fichier texte du nom de val_aleatoire.txt, ou un nom de votre choix, dans votre répertoire de source et placez y le chiffre 0.
-----------------------------------------------
Exercice 32
Les arguments : int main(int argc, char *argv[]);
La commande strlen(); retourne la taille d'une chaine de caractère.
-----------------------------------------------
Exercice 33
Les fonctions de mémoire dynamique :
malloc(taille); assigne une taille mémoire.
free(variable); libère une taille mémoire.
sizeof(int); indique la taille d'un élément.
-----------------------------------------------
Test 01
Le temps est venu de commencer à tester la rapidité d'une fonction.
gcc -o test1.prg test1.c; time ./test1.prg
-----------------------------------------------
Exercice 34
La commande write(1,&x,1);
Voici une série d'exercice sur le sujet de la commande write et la manipulation de variable, vous pouvez aussi créer des nouvelles fonctions, vous pouvez donner le nom que vous voulez à vos fonctions, en premier vous devez être capable de comprendre votre programme, rien ne vous empéchera par la suite de modifier les noms de vos fonctions en langue anglaise ou tout autre de votre choix (cela fera l'objet d'un exercice).
Dans un travail en commun vous devrez en discuter et utiliser les mêmes termes. (Le bon, la brute et le truand).
Note : Vous pouvez faire appel à une fonction dans une fonction.
-----------------------------------------------
Exercice 35
Un peu de Cryptage simple.
Si vous le voulez bien, codez les lignes pour décrypter le message que vous écrivez dans les arguments au lancement du programme.
Voici un rappel de la table ASCII.
-----------------------------------------------
Exercice 36
Un peu de ménage :( mais à la suite de cela ce sera :)
Prenons l'exercice034, il contient seulement 5 fonctions et il est déjà difficile à lire.
Pour le rendre plus lisible, nous pouvons partager le code source en plusieurs parties :
Un programme principale .c
Un fichier .c des fonctions, on lui place aussi les mêmes #include que le programme principale.
Un fichier .h des définitions, toutes, terminées par un point virgule en fin de ligne et ont comprend l'utilité de faire un retour chariot avant la première parenthèse, vous pouvez copier le fichier .h dans votre bibliothèque, vous pourrez ainsi retrouver rapidement toutes vos fonctions.
A la compilation, il faudra utiliser *.c pour indiquer que l'ont veut compiler tous les fichiers .c présent dans le répertoire.
Pour vous donner un exemple de fichier .h voici stdio.h
-----------------------------------------------
Exercice 37
Dans l'exemple036b ont voit plein de x de y de i, ce n'est pas très parlant, sauf si vous avez programmé il y a très longtemps, comme moi, dans une autre galaxie.
Vous pouvez, si vous le désirez, utiliser des noms de variables plus représentatif.
-----------------------------------------------
Exercice 38
Le Cryptage à clef.
L'exercice sera, si vous le voulez bien, de coder les lignes pour décrypter le message.
Un autre exercice possible, bien sur si vous avez besoin d'envoyer des petits messages ;-) créez deux fichiers textes, un dans lequel vous placerez la clef (vous pourriez aussi penser à une demande au clavier pour indiquer la clef de cryptage au programme) et un dans lequel vous écrivez le message à crypter (ici vous pourriez penser à un cryptage à la volée pour écrire le message), ensuite codez deux programmes, un pour crypter et un pour décrypter. n'oubliez pas d'inclure une gestion d'erreur dans vos fonctions de gestion de fichiers.
Je pense que vous l'avez compris, maintenant il faut sécuriser la clef ;-) et trouver des moyens de la transmettre sans trop de risque.
-----------------------------------------------
Exercice 39
Bonjour, parfois nous devons incrémenter un nom de fichier, il existe plusieurs méthodes pour résoudre ce problème, je vous en propose un qui incrémente de 1 à 999 avec un test de dépassement.
L'exercice, si vous le voulez bien, sera de transformer le code pour incrémenter le fichier de 1 à 9999.
La commande sprintf (nom,%var,variable); peut servir, comme dans cette exemple, à tranformer un nombre en suite de caractères.
-----------------------------------------------
Exercice 40
Une Gestion d'erreur.
Bonjour, cette partie sera plus de l'information, il s'agit de la gestion d'erreur :
Il est important de faire une bonne gestion d'erreur, donc de prévenir l'utilisateur de tous les problèmes et si l'ont veux bien faire ont peut aussi montrer que tout va bien, ne laissez jamais l'utilisateur sans information, vous pouvez utiliser les bibliothèques de gestion d'erreur à votre disposition quel que soit le langage que vous allez utiliser.
Dans certains cas il sera hors de question de quitter le programme mais de corriger l'erreur, bien sur vous devez avant toutes opérations délicates sauvez vos variables, prévoyez des places plus grande que trop juste, les équipements actuels ont une capacité de stockage énorme.
N'oubliez pas de tester toutes les possibilités de votre gestion d'erreur, faite des simulations avec des données erronées, même s'il vous parait improbable que l'erreur survienne, par exemple un disque dur abimé peut envoyer de fausse information, un DVD pourrait avoir des champignons dans les cavitées et changer certaines valeurs, une clef usb en surchauffe .... enfin bref une mauvaise information peut arriver n'importe quant.
Vous pouvez voir un exemple de gestion d'erreur sur le graphique, je determine en premier si le cas d'une erreur se présente et ensuite je prends les décisions.
-----------------------------------------------
Exercice 41
La notion du Makefile.
Le Makefile est utile pour générer différents fichiers de nos travaux, je vais vous présenter 3 versions, du plus simple au plus compliqué, vous pourrez vous adapter à la version qui vous conviendra.
La Première version est simple, j'indique le nom des fichiers car mon projet est court et ne contient que entre 1 et 3 fichiers.
Dans la seconde version j'ajoute des variables, toujours dans cette version pour quelques fichiers sources, je n'aurai besoin que de modifier les noms de fichiers dans ma déclaration de variable.
Et enfin la 3éme version sera la plus générique possible, quel que soit le nombre de fichier et quel que soit les noms des fichiers sources, mais elle est aussi la plus compliqué.
Dans mes Makefiles, je peux compiler les sources en tapant la commande (make all), aussi créer un fichier d'archive au format ZIP en tapant la commande sur le terminal (make zip), ou bien d'effacer les fichiers compilés avec la commande (make cleanall), ainsi que générer un fichier de débug en tapant (make debug), lancer mon programme compilé (make prg) etc.... et par exemple écrire une commande pour copier le fichier ZIP dans un dossier servant de transfert.
----------------------------------------------
Exercice 42
Un menu de base, le programme utilise la combinaison -- Do While et Switch Case.
-----------------------------------------------
J'espère que ce site vous sera utile
Bonne journée et bon code et surtout amusez vous bien.
Sept 2018 - Cumulus - Frantz Boukhovtzeff
|
| |
|
