imie-pour-tous.html#r7037206">Niveau 4
posons de créer zMol, un calculateur de masse molaire. N'ayez pas peur si vous ne savez pas ce que c'est : toutes les notions pré-requises et externes à la programmation seront expliquées.
Si vous souhaitez plus de renseignements sur les défis, rendez vous sur le topic de recensement des défis, vous y trouverez également les règles principales.
zMol, la chimie pour tous
Cet exercice a été écrit par _Fender_, un grand merci à lui !
Un calculateur de masse molaire ?
Aujourd'hui l'exercice sera de réaliser un calculateur de masse molaire. Cette notion de chimie n'est abordée qu'en classe de seconde générale, mais vous devriez vous en sortir même si vous êtes au collège, du moment que vous avez une bonne connaissance des molécules et des atomes.
Pour les non-initiés donc, il faut savoir que chaque atome a ce qu'on appelle une masse molaire atomique. Pour faire court, il s'agit de la masse que pèse une mole de cet atome (si vous êtes curieux, vous pouvez en apprendre plus sur les moles ici ! ). Chaque molécule a une masse molaire moléculaire, que l'on obtient en faisant la somme de tous les masses molaires atomiques des atomes qui la composent.
L’unité de la masse molaire est le <math>\(g.mol^-^1\)</math>.
Consignes
Le but de l'exercice est donc de réaliser un programme qui calcule la masse molaire d'une molécule entrée par l'utilisateur, et ce grâce à un fichier texte contenant certains atomes et leur masse molaire atomique correspondante.
Exemple :
Entrez une molécule :
--> CO2
La masse molaire de cette molécule est 44.0090 g.mol-1
Je vous propose de commencer à travailler avec ce petit fichier texte, il sera amplement suffisant pour faire des tests et pour couvrir un bon nombre de molécules :
C 12.011
O 15.999
H 1.0079
He 4.0026
Li 6.941
Cl 35.453
Na 22.989
Objectifs
Manipuler la lecture de fichiers.
Apprendre à se servir de quelques fonctions de la bibliothèque standard.
Apprendre (ou approfondir) une nouvelle notion en chimie.
Pistes de réflexion
Reconnaître un atome.
Vous pouvez remarquer que les symboles de certains atomes prennent un caractère et d'autres deux. Quand notre programme aura à analyser l'atome de chlore (Cl), par exemple, il ne faudra pas qu'il l'interprette comme un atome de carbone (C), et un atome l (inconnu au bataillon).
Heureusement, pour nous aider, une règle bien précise est que le deuxième caractère des symboles des atomes est toujours en minuscule, et le premier en majuscule. Pour cela, il va falloir utiliser les fonctions suivantes :
int isupper(int c); // Teste si un caractère est majuscule
int islower(int c); // Teste si un caractère est minuscule
/* Ces deux fonctions sont définies dans <ctype.h> */
Bien sûr, je ne vous donne là que quelques pistes, l'essentiel des recherches sur les problèmes que vous rencontrerez étant à faire par vous même (sinon, ça ne sert à rien).
Enoncé
Niveau 1
Faire un programme qui gère uniquement une liste d'atomes de symbole n'ayant qu'un caractère, écrits les uns à la suite des autres :
Entrez une molécule :
--> COO
La masse molaire de cette molécule est 44.0090 g.mol-1
Niveau 2
Cette fois, votre programme devra gérer les atomes dont le symbole fait plusieurs caractères.
Entrez une molécule :
--> NaCl
La masse molaire de cette molécule est 58.442000 g.mol-1
Niveau 3
Votre programme devra gérer les coefficients. Pour tester si un caractère est un chiffre, vous devrez utiliser une fonction de la même famille que isupper et islower (à vous de chercher seul, cette fois ).
La fonction strtol peut aussi vous être utile.
Entrez une molécule :
--> CO2
La masse molaire de cette molécule est 44.0090 g.mol-1
Niveau 4
Votre programme devra gérer les groupes qui se répètent plusieurs fois.
Entrez une molécule :
--> (CH4)2
La masse molaire de cette molécule est 32.085200 g.mol-1
Niveau 5
Les scientifiques viennent de découvrir un tout nouvel atome !! Ajoutez à votre programme une fonction qui vous permettra d'ajouter un atome et sa masse molaire dans votre fichier.
Et après... ?
Si vous réalisez les 5 niveaux, vous pouvez encore aller plus loin si vous le souhaitez !
Par exemple, vous pouvez décider d'afficher les étapes intermédiaires du calcul... Votre imagination est votre seule limite !
Bon courage.
Si il y a quelque chose que vous ne comprenez pas, n'hésitez pas à poser votre question sur ce sujet, nous vous répondrons avec plaisir !
Enfin, voici une liste de molécules avec leurs masses molaires correspondantes pour vous permettre d'effectuer vos tests.
Nom
Formule
Masse molaire
Informations
Monoxyde de carbone
<math>\(CO\)</math>
<math>\(28.01\)</math>
Le monoxyde de carbone est un gaz incolore, inodore et toxique, première cause de décès par intoxication en France (environ une centaine de cas en 2006).
Monoxyde de dicarbone
<math>\(C_2O\)</math>
<math>\(40.02\)</math>
Le monoxyde de dicarbone est composé de deux atomes de carbone et d'un atome d'oxygène. Il appartient à la famille des oxydes de carbone.
Benzène
<math>\(C_6H_6\)</math>
<math>\(78.11\)</math>
Le benzène a autrefois été utilisé comme solvant industriel (jusqu'a ce que sa toxicité devienne génante). Il est encore utilisé aujourd'hui notamment dans l'essence pour éviter les risques de détonation.
Acétone
<math>\((CH_3)_2CO\)</math>
<math>\(58.08\)</math>
L'acétone est principalement utilisé comme dissolvant. Les chimistes l'apprécient également pour sa capacité à solubiliser de nombreuses espèces organiques.
Dihydroxyacétone
<math>\(CO(CH_2OH)_2\)</math>
<math>\(90.08\)</math>
Le dihydroxyacétone (DHA) est notamment utilisé en cosmétique dans la production d'autobronzants.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "fonction5.h"
#include "element.h"
void vider_buffer()
{
int c = 0;
while (c != '\n' && c != EOF)
{
c = getchar();
}
}
int lire(char *chaine, int longueur)
{
char *positionEntree = NULL;
if (fgets(chaine, longueur, stdin) != NULL)
{
positionEntree = strchr(chaine, '\n');
if (positionEntree != NULL)
{
*positionEntree = '\0';
}
else
{
vider_buffer();
}
return 1;
}
else
{
vider_buffer();
return 0;
}
}
/*Fonction pas standard, j'ai donc repris le code ici*/
char * strndup (const char *s, size_t n)
{
char *result;
size_t len = strlen (s);
if (n < len)
len = n;
result = (char *) malloc (len + 1);
if (!result)
return 0;
result[len] = '\0';
return (char *) memcpy (result, s, len);
}
/*Permet d'extraire une partie d'une chaine*/
char *sub_str (char *src, int pos, int len)
{
return strndup(&src[pos], len);
}
/*Fonction qui vérifie si l'élément que l'on regarde existe dans la liste*/
int search_tab(char* lettre, Element elem[], int nbelem)
{
int i = 0;
for(i = 0; i < nbelem; i++)
{
if(strcmp(lettre, elem[i].nom) == 0)
{
return i;
}
}
printf("Element %s non reconnu\n", lettre);
return -1;
}
/*Fonction qui remplie le tableau de Element via un fichier qui contient les infos nécessaire*/
int get_file(Element elem[])
{
int i = 0;
FILE* fichier = fopen("rc/mol", "r+");
if(!fichier)
{
printf("Impossible d'ouvrir le fichier rc/mol\n");
exit(-1);
}
while(!feof(fichier))
{
fscanf(fichier, "%s %lf\n", elem[i].nom, &elem[i].val);
i++;
}
fclose(fichier);
return i;
}
double result(char* mol)
{
int i = 0;
int a = 0;
int j = 0;
int coef = 1;
int len = 0;
int nbelem = 0;
Element elem[112];
double ret = 0.0;
char test[3] = {0};
char* parenthese = NULL;
nbelem = get_file(elem);
len = strlen(mol);
while(i < len)
{
/*Si la chaine contient une parenthèse fermante*/
if(strstr(mol, ")") != NULL)
{
parenthese = strstr(mol, ")");
/*On suppose qu'après la parenthèse se trouve le coefficient multiplicateur
strtol s'arrêtant au premier caractère non convertible, ça ne gène en rien*/
coef = strtol(parenthese+1, NULL, 10);
/*Extrait ce qu'il y a entre parenthèse et l'ajoute X fois au résultat selon le coefficient*/
parenthese = sub_str(mol, 0, parenthese-mol);
for(j = 0; j < coef; j++)
{
ret+=result(parenthese);
}
free(parenthese);
return ret;
}
else
{
/*Pour les cas d'espèce chimique sur deux lettres et avec un coefficient*/
if(isupper(mol[i]) && islower(mol[i+1]) && isdigit(mol[i+2]))
{
test[0] = mol[i];
test[1] = mol[i+1];
a = search_tab(test, elem, nbelem);
elem[a].coeff = strtol(mol+(i+2), NULL, 10);
i+=3;
}
/*Une lettre avec coefficient*/
else if(isupper(mol[i]) && isdigit(mol[i+1]))
{
test[0] = mol[i];
test[1] = 0;
a = search_tab(test, elem, nbelem);
elem[a].coeff = strtol(mol+(i+1), NULL, 10);
i+=2;
}
/*Deux lettres sans coefficient*/
else if(isupper(mol[i]) && islower(mol[i+1]))
{
test[0] = mol[i];
test[1] = mol[i+1];
a = search_tab(test, elem, nbelem);
elem[a].coeff = 1;
i+=2;
}
/*Une lettre*/
else
{
test[0] = mol[i];
test[1] = 0;
a = search_tab(test, elem, nbelem);
elem[a].coeff = 1;
i++;
}
/*Si l'espèce chimique est répertorié, on ajoute sa masse multipliée par le coefficient*/
if(a != -1)
{
ret+=elem[a].val*elem[a].coeff;
}
}
}
return ret;
}
/*Fonction pour ajouter une espèce chimique, basique ^^*/
void add(void)
{
char nom[4] = {0};
double masse = 0.0;
FILE* fichier = fopen("rc/mol", "r+");
if(!fichier)
{
printf("Impossible d'ouvrir le fichier rc/mol\n");
exit(-1);
}
printf("Entrez le diminutif de l'espèce chimique :\n");
printf("--> ");
fflush(stdout);
lire(nom, 3);
printf("Entrez la masse molaire moléculaire correspondante :\n");
printf("--> ");
fflush(stdout);
scanf("%lf", &masse);
fseek(fichier, 0, SEEK_END);
fprintf(fichier, "%s %.1f\n", nom, masse);
fclose(fichier);
}
/*Menu basique aussi*/
void menu(void)
{
int choix = 0;
printf("Bienvenu dans le zMol !\n");
while(choix != 1 && choix != 2)
{
printf("Choisissez une action:\n");
printf("\t1. Calcul\n");
printf("\t2. Ajouter une espèce chimique\n");
printf("--> ");
fflush(stdout);
scanf("%d", &choix);
vider_buffer();
}
switch(choix)
{
case 1:
calc();
break;
case 2:
add();
break;
default:
break;
}
}
void calc(void)
{
double ret = 0.0;
char* envoie = NULL;
char mol[100] = {'\0'};
char resultat[100] = {'\0'};
printf("Entrez une molécule :\n");
printf("--> ");
fflush(stdout);
scanf("%s", mol);
/*Strtok modifie la chaine, on la stocke ailleurs pour l'affichage finale*/
strcpy(resultat, mol);
/*Si on trouve une parenthèse au moins dans la molécule*/
if(strstr(mol, "(") != NULL)
{
/*On extrait la chaine avant la parenthèse*/
envoie = strtok(mol, "(");
while(envoie != NULL)
{
ret += result(envoie);
envoie = strtok(NULL, "(");
}
}
/*S'il n'y a aucune parenthèse dans la molécule*/
else
{
ret = result(mol);
}
printf("La masse molaire de la molécule %s est %.1f g.mol-1\n", resultat, ret);
}
Fonction5.h
#ifndef FONCTION_H_INCLUDED
#define FONCTION_H_INCLUDED
#include "element.h"
int lire(char *chaine, int longueur);
long get_masse(void);
void vider_buffer(void);
void menu(void);
char *sub_str (char *src, int pos, int len);
double result(char* mol);
int search_tab(char* lettre, Element elem[], int nbelem);
void calc(void);
int get_file(Element elem[]);
#endif
Euh ouais. Deux petits fails de ma part.
Le coup du '\n' final, c'est je crois dû à une flemme subconsciente de calculer le bon décalage des indices à partir de strlen(mol)... /o\
C'est corrigé ici : http://pastebin.archlinux.fr/433879. Du coup le main() est vraiment moche mais bon, la partie intéressante est dans getMolMass :]
Est-ce qu'on doit gérer les trucs du genre : C + O2
Sabeurre > J'ai regardé ton code en travers, tu penses pas que tu pourrais faire plus léger ? je pense notamment aux strstr pour chercher un caractère et aux strtok.
J'ai l'impression que tu fais pas mal de répétitions, tu peux sûrement smplifier.
Armael > Pourquoi faire 2 fois 'printf("\n%f\n", getMolMass(mol));' dans ton main ? tu peux ne le faire qu'une seule fois.
Tu ne peux pas faire de comparaisons de flottans comme tu le fais, tu as une chance sur 2 que ça ne fonctionne pas : if(cur_item_mass != 0.0)
Si je dis pas de conneries, les éléments ne comportent que 2 lettres, donc inutile de gérer les éléments avec X lettres.
Tu pourrais (devrais) ouvrir ton fichier une fois pour toutes et le garder en mémoire plutôt que l'ouvrir à chaque élément.
Si j'imbrique plusieurs parenthèses, ton code donnera un résultat faux (comme je n'ai pas eu de réponse par rapport à ça, oublie ce commentaire...)
Que vaut 2CO2 ? sûrement pas 44.008999
- Hm, où je fais deux fois printf( ,getMolMass(mol)) ?
- Pour les flottants, je me suis dit que lorsque cur_item_mass est à 0 c'est parce qu'il y a été initialisé explicitement, et ça marcherait. Après, j'en sais trop rien, j'vais regarder ça.
- Pour les éléments qui font max. deux lettres, c'est que j'avais un doute sur le sens de «Les scientifiques viennent de découvrir un tout nouvel atome !! Ajoutez à votre programme une fonction qui vous permettra d'ajouter un atome et sa masse molaire dans votre fichier. » et j'ai décidé d'autoriser les fantaisies
- Hum, regarde mon dernier post
- Je looke ça pour l'imbrication de parenthèses, ça devrait marcher. [FIXED]
- 2CO2 n'a pas de sens ! Tu veux dire (CO2)2 (qui lui est correctement interprêté) ?
Avec le argc et le dernier else.
2CO2 n'a peut-être pas de sens, mais si je prends le lien donné plus haut (cf celui-ci : http://sciences.siteduzero.com/tutorie [...] es-moles.html ) ils donnent bien des formules avec des indices préfixés et postfixés.
Et, quand on disait de n'ouvrir ton fichier, on parlait surtout de ne le parcourir qu'une seule fois et de stocker tout en mémoire, pas de faire un 'rewind' à chaque appel de fonction.
Le but de l'exercice est donc de réaliser un programme qui calcule la masse molaire d'une molécule entrée par l'utilisateur, et ce grâce à un fichier texte contenant certains atomes et leur masse molaire atomique correspondante.
Fastoche^^
Citation : Exercices C
Objectifs
Manipuler la lecture de fichiers.
Apprendre à se servir de quelques fonctions de la bibliothèque standard.
Apprendre (ou approfondir) une nouvelle notion en chimie.
Mince, j'ai pas encore le niveau (je suis en train de lire le tutoriel, justement sur ce chapitre)
*Court lire la suite*
Ah mais nan, c'est vrai
*Vient de se rappeler qu'elle a un autre "truc" à voir et qu'elle attend une réponse*
Bon, ce sera pour la prochaine fois...
Citation : Ccile
Objectifs
Manipuler la lecture de fichiers.
Apprendre à se servir de quelques fonctions de la bibliothèque standard. Apprendre (ou approfondir) une nouvelle notion en chimie. (la sait déjà)
Avoir un énième TP d'entrainement à faire
Ce message est là pour me rappeler de faire le défi (une fois que j'aurais le niveau) et pour encourager les créateurs d'exercices à continuer sur la voie du mélange des matières^^
Ok, ok, je m'en vais je m'en vais...
Comme promis, mon code.
L'énoncé rapidement lu avait l'air plutôt facile, mais finalement il est un peu plus compliqué qu'il n'y paraît.
/* -> zMol - par lucas-84 pour www.siteduzero.com.
* -> Défi #1 d'une série d'exercices lancée par GuilOoo.
* -> Merci aux organisateurs, à savoir : _Fender_, GuilOooo, yoch,
* InfernoLeZéro, @che, neowillow, lucas-84 et schadocalex.
* -> L'énoncé est à cette adresse :
* http://www.siteduzero.com/forum-83-686358-p1-defis-1-zmol-
la-chimie-pour-tous.html
* -> Venez vous entraîner, et bonne lecture !
*/
/* main.c */
#ifdef _cplusplus
#error Ce fichier source n'est pas en C++. \
Merci d'utiliser un compilateur C.
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* Pour les fonctions de manipulation des chaînes. */
#include <ctype.h> /* Pour les fonctions de la famille de isalpha(). */
/* constants =========================================================== */
/*
* Taille maximale d'une molécule saisie par l'utilisateur.
*/
#define MAX_LEN 64
/*
* Nom du fichier contenant la masse de chaque atome
*/
#define FILE_NAME "fichier.txt"
/* structures ========================================================== */
/*
* Structure d'un élément chimique.
*/
typedef struct {
char s_name[MAX_LEN]; /* Désignation de l'élément. */
double mass; /* Masse de l'élément. */
} Element_s;
/* private functions =================================================== */
/* Niveau d'abstraction 5 */
/*
* Nettoie le buffer.
*/
static void
clean(void)
{
int c;
while ((c = getchar()) != '\n' && c != EOF);
}
/*
* Lis une chaîne de caractère s_read de taille size sur le flux
* d'entrée standard.
*/
static void
read_string(char *s_read, int size)
{
char *ptr_end = NULL;
if (fgets(s_read, size, stdin) != NULL) {
ptr_end = strchr(s_read, '\n');
if (ptr_end != NULL) {
*ptr_end = '\0';
} else {
clean();
}
}
}
/* Niveau d'abstraction 4 */
/*
* Cherche un atome searched_atom->s_name dans le fichier p_stream,
* et retourne sa masse.
*/
static void
search_in_file(FILE * p_stream, Element_s *p_searched_atom)
{
Element_s read_atom;
while (fscanf(p_stream, "%s %lf",
read_atom.s_name, &read_atom.mass) == 2) {
if (!strcmp(read_atom.s_name, p_searched_atom->s_name)) {
p_searched_atom->mass = read_atom.mass;
}
}
}
/* Niveau d'abstraction 3 */
/*
* Initialise la structure que pointe p_struct.
*/
static void
init(Element_s * p_struct)
{
p_struct->mass = .0;
}
/*
* Fonction principale du traitement d'un atome.
*/
static double
treat_atom(FILE * p_stream, char s_molecule_name[], Element_s * p_atom,
int *i)
{
int var = 0;
p_atom->s_name[var++] = s_molecule_name[*i];
while (islower(s_molecule_name[*i + 1])) {
p_atom->s_name[var++] = s_molecule_name[++(*i)];
}
p_atom->s_name[var] = '\0';
search_in_file(p_stream, p_atom);
if (p_atom->mass == .0) {
fprintf(stderr, " L'atome %s est introuvable.\n", p_atom->s_name);
}
return p_atom->mass;
}
/* Niveau d'abstraction 2 */
/*
* Récupère la molécule ps_mol saisie par l'utilisateur.
*/
static void
get_mol(char *ps_mol)
{
printf(" Entrez une molécule (-add [nom][masse] pour en ajouter"
" une) :\n --> ");
read_string(ps_mol, MAX_LEN);
}
/*
* Affiche le résultat molecule_mass.
*/
static void
print_result(double molecule_mass)
{
printf("\n La masse molaire de cette molécule est %f g.mol-1.\n",
molecule_mass);
}
/*
* Fonction principale du traitement d'une molécule.
*/
static double
treat_molecule(FILE * p_stream, char s_molecule_name[])
{
int i;
double prev_mass = .0;
double result = .0,
tmp_mass = .0;
Element_s atom;
init(&atom);
for (i = 0; s_molecule_name[i] != '\0'; i++, atom.mass = 0) {
if (isupper(s_molecule_name[i])) {
tmp_mass += treat_atom(p_stream, s_molecule_name, &atom, &i);
result += atom.mass;
} else if (isdigit(s_molecule_name[i])) {
result +=
(prev_mass * (strtol(&s_molecule_name[i], NULL, 10) - 1));
tmp_mass +=
(prev_mass * (strtol(&s_molecule_name[i], NULL, 10) - 1));
} else if (s_molecule_name[i] == '(') {
tmp_mass = 0.;
} else if (s_molecule_name[i] == ')'
&& isdigit(s_molecule_name[i + 1])) {
result +=
(tmp_mass *
(strtol(&s_molecule_name[i + 1], NULL, 10) - 1));
}
prev_mass = atom.mass;
rewind(p_stream);
}
return result;
}
/*
* Ajoute un atome dans le fichier.
*/
static int
add_atom(char *cmd)
{
FILE *p_stream;
int i;
if (!(p_stream = fopen(FILE_NAME, "a+"))) {
fprintf(stderr, " Erreur lors de l'ouverture du fichier.\n");
return 0;
}
for (i = 5 ; cmd[i] != '\0' ; i++) {
fputc(cmd[i], p_stream);
}
fclose(p_stream);
return 1;
}
/* Niveau d'abstraction 1 */
/*
* Fonction principale du programme. Renvoie 1 si tout s'est bien passé
* ou 0 le cas échéant.
*/
static int
zMol(void)
{
FILE *p_stream;
Element_s molecule;
init(&molecule);
if (!(p_stream = fopen(FILE_NAME, "r"))) {
fprintf(stderr, " Erreur lors de l'ouverture du fichier.\n");
return 0;
}
get_mol(molecule.s_name);
if (!strncmp(molecule.s_name, "-add", 4)) {
return add_atom(molecule.s_name);
}
molecule.mass = treat_molecule(p_stream, molecule.s_name);
print_result(molecule.mass);
fclose(p_stream);
return 1;
}
/* entry points ======================================================== */
/* Niveau d'abstraction 0 */
int
main(void)
{
return (zMol())? EXIT_SUCCESS : EXIT_FAILURE;
}
J'ai mis pas mal de temps avant d'établir une solution fonctionnelle, et j'ai eu droit à de multiples bugs en tout genre. J'imagine qu'il doit en rester encore beaucoup...
Je précise que le code ci-dessus ne supporte pas encore l'imbrication de parenthèses.
Non non, ça c'est les coefficients pour équilibrer une équation. Une molécule seule ne possède jamais de nombres devant.
Juste pour le plaisir de parler quand (pour une fois) je connais :
Ces coefficients sont nommés nombres stœchiométriques et servent à équilibrer une équation (comme dit avant). En gros, dans l'équation suivante :
2tranches de pain + 1tranche de jambon =>1sandwich
les nombres (1 et 2) sont des nombres stœchiométriques (mais le 1 on ne le met pas)
(désolée de l'exemple hs par rapport à la chimie, mais c'est l'exemple qui fut utilisé par ma prof lorsque l'on a appris les tableaux d'avancement^^, je sais, je suis une sentimentale )
(bon, c'est aussi hors-sujet par rapport au topic, mais autant donner le bon vocable non? (excuse médiocre je sais...))
C'est pas du tout HS, c'est même un des principaux objectifs :
Citation
Objectifs
* Manipuler la lecture de fichiers.
* Apprendre à se servir de quelques fonctions de la bibliothèque standard.
----->* Apprendre (ou approfondir) une nouvelle notion en chimie.
Moi aussi j'ai eu droit au coup de "l'optimisation d'une sandwicherie".
Ah, pouet, on t'as pas répondu je crois. Au niveau 4, l'imbrication "maximale" est celle avec une seule paire de parenthèse. Et non, on ne doit pas gérer "les trucs du genre : C + O2".
Twisted Destiny et Ccile -> Moi aussi.
"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
Moi aussi j'ai eu droit au coup de "l'optimisation d'une sandwicherie".
Citation : schadocalex
Twisted Destiny et Ccile -> Moi aussi.
Alors, soit on a eu la même prof, soit les profs de physique-chimie devraient penser à changer un peu
(Pour être un peu moins HS qu'un commentaire de commentaire, je tiens à signaler ici à mes fans (comment ça j'ai la grosse tête?!? ) que je vais ré-attaquer incessamment sous peu (enfin, dès que j'aurai fini la vaisselle ) la partie du tutoriel sur les fichiers et donc que je m'avance petit à petit vers l'écriture du code demandé )
Je préfère approfondir mes connaissances avant^^ (et laisser par la même occasion mon cerveau trouver un schéma possible de code, car si je sais le faire à la main sans aucun souci... programmer ça me semble plus... tordu :D)
Ce code fonctionne pour le niveau 4 mais il reste encore à enlever certaines répétitions et, comme dit un peu avant, éviter d'ouvrir le fichier à chaque appel de la fonction...
La partie de code en commentaire était une répétition que j'ai enlever en modifiant la partie avec le "isupper()".
Merci de regarder le code et de me faire des remarques pour que je puisse m'améliorer.
Bouh le nom du fichier de conf hardcodé
Utilise quelques define pour ça et la taille de tes tableaux (genre tous les mol[100]...). Élimine les "nombres magiques" quoi
En tout cas maintenant mon code gère bien un nombre illimité d'imbrications et c'est ce qui était voulu au départ, y avait juste un ptit bug à fixer.
Ça se fait très simplement et naturellement avec un appel récursif.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.
🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles - ♡ Copying is an act of love.