Travail sur les systèmes de Lindenmayer ou L-systèmes

Déplacé depuis le forum C à la demande de l'auteur.

Bonjour et Bonnes Fêtes à tous!

J'ai un travail de programmation à réaliser en C sur les systèmes de Lindenmayer ou L-systèmes et j'ai bien du mal à débuter! Étant aussi débutant en programmation...

Voici une petite explication du sujet:

http://nsa21.casimages.com/img/2011/...1425157016.jpg

J'ai un soucis avec la fonction (nouveau_symbole) décrite ci-après:

http://nsa22.casimages.com/img/2011/...1822674365.jpg

En effet, je ne sais pas faire une fonction qui change de valeur de sortie quand on l’exécute... Si vous pouviez me mettre sur la piste, je vous en remercierais fortement!

Bonne après-midi!

Guillaume.

Salut,

Dans ton cas, je pense que seule une variable statique fera l'affaire. Tu peux alors simplement coder la fonction comme ça :

Code:

---

1 2 3 4 5

char nouveau_symbole(void) { static char symbol = 'a' - 1; // Initialisation du symbole return ++symbol; // Incrémentation du symbole puis retour. }

---

Au premier appel, ça retournera 'a', puis 'b', etc. Évidemment une fois à 'z' ça ne va plus retourner des lettres, à toi de gérer ce cas en fonction des contraintes.

Bonjour et merci pour ta réponse! :ccool:

Citation:

---

Envoyé par Trademark

Code:

---

1 2 3 4 5

char nouveau_symbole(void) { static char symbol = 'a' - 1; // Initialisation du symbole return ++symbol; // Incrémentation du symbole puis retour. }

---

---

Une petite question: Que signifie le - 1?


Guillaume.

Citation:

---

Envoyé par Guillaume1989

Une petite question: Que signifie le - 1?

---

En fait, en C, les caractères sont officiellement des nombres entiers. « 'a' » se lit donc, sémantiquement, « le caractère a » mais est en pratique une expression renvoyant un nombre entier correspondant à ce caractère dans le jeu d'exécution de base, soit, dans les faits et pour faire simple, le code ASCII de « a ».

« 'a' - 1 » permet donc d'initialiser la variable statique avec la valeur qui le précède immédiatement. Ceci parce que l'instruction suivante pré-incrémente la variable avant d'en retourner la valeur. Ça permet donc de continuer à utiliser cette pré-incrémentation tout en commençant bien à « a ».

D'accord merci pour ce renseignement! :)


Un autre soucis: j'ai créée ma fonction egaux qui permet de voir si deux symboles sont identiques mais j'ai un problème avec les pointeurs... Comment récupérer, à la sortie de la fonction nouveau_symbole, les deux symboles à comparer?

Merci!

En fait, dans l'énoncé, il y a une abstraction du type d'un symbole. Et vous manipulez seulement des pointeurs. Donc, il faudrait peut-être modifier la précédente fonction pour obtenir quelque chose comme ça :

Code:

---

1 2 3 4 5 6 7 8

typedef char symbole; // On définit l'abstraction demandée. symbole* nouveau_symbole(void) { static symbole symbole_courant = 'a'; // Initialisation du symbole symbole* nouveau = malloc(sizeof(symbole)); // On crée le symbole (réservation de l'espace mémoire). *nouveau = symbole_courant++; // On affecte le symbole que nous incrémentons juste après. return nouveau; // Retour du symbole créé }

---

Pour rappel, on accède à la valeur d'un pointeur via '*'. Ce qui est alloué via malloc doit être détruit via un free.

La responsabilité de la fonction nouveau_symbole est maintenant de créer en mémoire un symbole et de l'initialiser. (J'ai pu changer le "'a' - 1" qui te perturbait).

Bon travail !

Bonjour!

Plus haut dans mon sujet, on demande de définir symbole comme une structure (struct symbole), le type symbole représentant les symboles de l’alphabet V. D'où le fait que vous parliez d'abstraction de ce type... Je n'en avais pas parlé... :mrgreen:

Je l'ai donc défini ainsi:

Code:

---

struct symbole { char sym; }

---

Il faut que mon "sym" corresponde avec l'élément que renvoie ma fonction nouveau_symbole, correct? Par exemple "nouveau" dans la dernière définition, c'est ça?

Je comprends mieux ta deuxième version mais je ne dois éviter d'utiliser malloc et free d'après le sujet:

Citation:

---

Le fichier rendu par l’élève ne doit faire appel à aucune fonction externe, excepté éventuellement malloc et free ; l’élève préférera cependant utiliser les opérateurs new et delete.

---

Je croyais que "new" et "delete" c'était en c++... Je ne trouve aucune info sur leur utilisation en c...

Merci!

A la place de cette ligne :

Code:

---

*nouveau = symbole_courant++;

---

Tu auras :

Code:

---

nouveau->sym = symbole_courant++;

---

Une structure peut être déclarée comme suit :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

typedef struct symbole{ char sym; } // Définition du type "symbole"   // Exemples struct symbole s; s.sym = 'a';   // Plus court grâce au "typedef" précisé plus haut symbole s; s.sym = 'a';   // Et dans le cas d'un pointeur symbole *s = malloc(sizeof(symbole)); (*s).sym = 'a'; // Ou (méthode préférée) s->sym = 'a'; // Ne pas oublier free(s);

---

Les opérateurs pour accéder aux champs d'une structure sont '.' et '->' suivant que c'est un pointeur ou non.

new et delete c'est du C++, dans ton cas, il me semble qu'il faut privilégier malloc et free vu que c'est du C et que tu programmes en C "pur". Compiles tu avec gcc (compilateur C) ou g++ (compilateur C++) ? Un programme C peut être compilé grâce à g++ mais l'inverse n'est pas vrai. Donc il vaut mieux que tu t'astreignes à programmer en C pur et à compiler avec gcc.

Re!

Citation:

---

Envoyé par Trademark

A la place de cette ligne :

Code:

---

*nouveau = symbole_courant++;

---

Tu auras :

Code:

---

nouveau->sym = symbole_courant++;

---

---

Si j'ai bien compris: le "->" permet d'accéder au champ "sym" à partir de l'identificateur "nouveau". Cela signifie que le nouveau symbole "est maintenant dans la structure symbole" ?

Code:

---

typedef struct symbole{ char sym; }; ]

---

Cette définition de la la structure "symbole" est correcte et en équation avec la fonction "nouveau_symbole" maintenant, non?

Citation:

---

Envoyé par Trademark

new et delete c'est du C++, dans ton cas, il me semble qu'il faut privilégier malloc et free vu que c'est du C et que tu programmes en C "pur". Compiles tu avec gcc (compilateur C) ou g++ (compilateur C++) ? Un programme C peut être compilé grâce à g++ mais l'inverse n'est pas vrai. Donc il vaut mieux que tu t'astreignes à programmer en C pur et à compiler avec gcc.

---

Oui, je dois programmer en C et je compile avec gcc.

C'est laborieux... :bug:

Merci beaucoup pour l'aide! :merci:

Citation:

---

Envoyé par Guillaume1989

Si j'ai bien compris: le "->" permet d'accéder au champ "sym" à partir de l'identificateur "nouveau". Cela signifie que le nouveau symbole "est maintenant dans la structure symbole" ?

---

Oui c'est ça, mais il faut que "nouveau" soit un pointeur sinon tu ne peux pas utiliser "->" mais tu dois utiliser '.'. L'opérateur "->" est équivalent à un dé-référencement (opérateur '*') de ta variable (c'est à dire accéder à la valeur pointée par la variable, rappel : un pointeur contient l'adresse d'une variable) + l'opérateur "." pour accéder aux champs (comme montré avant).

Citation:

---

Envoyé par Guillaume1989

Code:

---

typedef struct symbole{ char sym; }; ]

---

Cette définition de la la structure "symbole" est correcte et en équation avec la fonction "nouveau_symbole" maintenant, non?

---

Oui, mais malgré ce que l'énoncé dit, utiliser une structure pour stocker une valeur c'est un peu idiot. Il aurait mieux valu "encapsulé" le type "char"... Exemple :

Code:

---

typedef char symbole;

---

Mais bon, tu n'as pas le choix apparemment.

Citation:

---

Envoyé par Trademark

Oui c'est ça, mais il faut que "nouveau" soit un pointeur sinon tu ne peux pas utiliser "->" mais tu dois utiliser '.'. L'opérateur "->" est équivalent à un dé-référencement (opérateur '*') de ta variable (c'est à dire accéder à la valeur pointée par la variable, rappel : un pointeur contient l'adresse d'une variable) + l'opérateur "." pour accéder aux champs (comme montré avant).

---

Aaah! Je comprends des choses!

Citation:

---

Envoyé par Trademark

Oui, mais malgré ce que l'énoncé dit, utiliser une structure pour stocker une valeur c'est un peu idiot. Il aurait mieux valu "encapsulé" le type "char"... Exemple :

Code:

---

typedef char symbole;

---

Mais bon, tu n'as pas le choix apparemment.

---

Je n'ai pas le choix non...

Les symboles que j'ai créés "vont" maintenant dans ma structure "symbole", seulement, comment les récupérer pour les utiliser dans la fonction egaux?
Car selon la définition donnée par le sujet:

Citation:

---

La fonction egaux(symbole const*, symbole const*) retourne true si les deux paramètres sont un même symbole ; false sinon.

---

D'après sa définition, la fonction "egaux" récupère les symboles à comparer d'elle-même non?
Le "symbole const*" signifie que l'on définit un pointeur sur quelque chose de constant en l’occurrence un symbole... Mais je ne vois pas comment aller " récupérer des symboles dans la structure "symbole" "...

Merci! :mrgreen:

Comme dit précédemment avec l'opérateur '.' ou '->'.

Code:

---

1 2 3 4 5 6 7 8 9 10

symbole *s = nouveau_symbole(); symbole *s2 = nouveau_symbole(); bool egalite = egaux(s,s2);   // ...   bool egaux(symbole const* s1, symbole const* s2) { return s1->sym == // ... Vous devriez trouver le reste de l'expression. }

---

Citation:

---

Envoyé par Trademark

Code:

---

1 2	symbole *s = nouveau_symbole(); symbole *s2 = nouveau_symbole();

---

---

Voilà c'est ça qu'il me manquait !!!

Merci! :ccool:

Il s'avère en fait que je dois programmer en C++ d'où le fait que je ramais un peu plus qu'en C++...

Merci de déplacer mon sujet dans C++.

Citation:

---

Envoyé par Guillaume1989

Merci de déplacer mon sujet dans C++.

---

C'est fait.

Bonsoir!

Merci d'avoir déplacer mon sujet.

Je m'en suis mieux sorti en C++ et j'ai bien avancé.

Voici la partie suivante où je bloque:

http://nsa22.casimages.com/img/2012/...1136478949.jpg

http://nsa22.casimages.com/img/2012/...1208654618.jpg

La création de la fonction mot* mot_vide(void) ne m'a pas posé problème, en effet j'ai déclaré la structure mot de la manière suivante:

Code:

---

struct mot{symbole* mo;};

---

et ai écrit:

Code:

---

1 2 3 4 5 6

mot* mot_vide(void) { mot* movid = new(mot); movid->mo = 0L ; return movid; }

---

le problème réside dans les fonctions suivantes:

Code:

---

1 2 3 4 5 6 7 8

mot* singleton(symbole const* a) { mot* sing = new(mot);   /* sing->mo = ??? ; je ne parviens pas à écrire correctement le fait que la fonction renvoie un singleton... j'ai écrit: sing->mo = a; mais ce n'est pas correcte de 'const symbole*' à juste 'symbole*'... */   return sing; }

---

Merci! :ccool:

Tu as deux problèmes dans ce code.

D'abord, le problème structurel.
Un "mot" doit pouvoir être constitué de plusieurs "symbole"s.
Donc ta structure mot est mal définie (tu peux te renseigner sur vector).

Et maintenant le problème en rapport avec ta question.
Tu as une variable "symbole const * a", et tu veux remplir une variable "symbole * mot".
Le souci est le const.
Il est évident que tu ne peux pas simplement retirer le const - en fait, techniquement, tu pourrais, mais ce n'est certainement pas l'objectif !
Ce qu'il te faut faire, c'est copier "a" dans "mot".

Par ailleurs, je comprends mal la présence de tous ces pointeurs dans l'énoncé ... Particulièrement pour "singleton", où une référence constante serait tellement plus pratique !
Ou bien vous n'avez pas encore vu les références ?
Par ailleurs, étant donné qu'on semble toujours avir des char comme "symbole"s, il me semblerait logique qu'on passe tout par copie, évitant donc beaucoup de travail ...

Salut,

Code:

---

movid->mo = 0L ;

---

Ce n'est pas "bien", pour la lisibilité (parce que, en lisant ton code on pourrait croire que movid->mo est un entier de type long) il vaut mieux faire :

Code:

---

mot_vide->symboles = NULL ;

---

(note le changement des noms de variables, d'une manière générale, il est préférable que le nom de la variable soit un peu plus long s'il est plus explicite.)

Ensuite pour ton problème, il y a deux choix :

1. Soit tu fais une copie du symbole qui ne sera pas constante ;
2. Soit tu déclares un mot de cette façon :
   Code:

   ---

   struct mot{const symbole* symboles;};

   ---

   Tu peux le faire si tu penses qu'un mot ne changera jamais de symbole. Et il me semble que c'est la meilleure solution, vu les prototypes des fonctions suivantes.

Bonsoir!

Merci pour la réponse!

Citation:

---

Envoyé par Equinoxe_

Tu as deux problèmes dans ce code.

Ce qu'il te faut faire, c'est copier "a" dans "mot".

---

Comment?

Bonsoir!
Merci pour la réponse!

Citation:

---

Envoyé par Trademark

Salut,

Code:

---

movid->mo = 0L ;

---

Ce n'est pas "bien", pour la lisibilité (parce que, en lisant ton code on pourrait croire que movid->mo est un entier de type long) il vaut mieux faire :

Code:

---

mot_vide->symboles = NULL ;

---

(note le changement des noms de variables, d'une manière générale, il est préférable que le nom de la variable soit un peu plus long s'il est plus explicite.)

Ensuite pour ton problème, il y a deux choix :

1. Soit tu fais une copie du symbole qui ne sera pas constante ;
2. Soit tu déclares un mot de cette façon :
   Code:

   ---

   struct mot{const symbole* symboles;};

   ---

   Tu peux le faire si tu penses qu'un mot ne changera jamais de symbole. Et il me semble que c'est la meilleure solution, vu les prototypes des fonctions suivantes.

---

NULL ne fonctionne pas.
C'est-à-dire faire une copie du symbole qui ne sera pas constante?

Merci!