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!

Citation:

---

Envoyé par Guillaume1989

Bonsoir!
Merci pour la réponse!

NULL ne fonctionne pas.

---

Pourquoi dis-tu ça ?

Citation:

---

Envoyé par Guillaume1989

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

Merci!

---

Oui mais d'après moi, et d'après l'énoncé, c'est plutot vers la deuxième méthode que tu dois te diriger, parce que sinon je vois pas l'intérêt de tout mettre constant et de passer les données par pointeur... Et surtout, ton professeur aurait prévu une fonction "copier" dans les prototypes donnés.

Sinon tu peux faire une copie comme ça :

Code:

---

1 2	singleton->symboles = new(symbole); // Allocation de la "chaine" de symbole, ici 1 symbole. singleton->symboles[0] = *a // Copie du symbole

---

@Guillaume1989: Pour faire une copie du symbole en passant par l'opérateur new, tu peux faire comme ça (avec une classe A, à toi d'adapter) : "A * copie = new A(*pointeur_sur_a_a_copier);"

Mais tu vas te retrouver avec un problème au moment des fonctions "concatener".
La solution peut alors être de stocker non pas un pointeur, mais un tableau.
Il se déclarerait exactement comme avant (si ce n'est qu'il y a une horrible faute d'orthographe sur le nom du champ -- pourquoi l'avoir appellé "mo" et pas "mot" ?), et s'utiliserait quelque peu différemment.
Entre autres, il faudrait stocker sa taille à côté.
Quelques exemples :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

struct mot { symbole * symboles; unsigned int longueur; };   mot * singleton(symbole const * s) { mot * m = new mot; // Créer un nouveau mot m->symboles = new symbole[1]; // Réserver de la place pour un symbole m->longueur = 1; // Et s'en souvenir m->symboles[1] = *s; // Enfin, copier le symbole dans le mot return m; // Et renvoyer le mot ainsi formé }   mot * concatener(mot const * m, symbole const * s) { mot * n = new mot; // Créer un nouveau mot n->symboles = new symbole[m->longueur + 1]; // Réserver de la place pour un mot de un symbole de plus que `m' n->longueur = m->longueur + 1; // Et s'en souvenir for (unsigned int i = 0 ; i < m->longueur ; ++i) { // Pour chaque symbole de l'ancien mot n->symboles[i] = *m->symboles[i]; // Le copier dans le nouveau } n->symboles[m->longueur] = *s; // Et copier le symbole à ajouter à la fin return n; // Enfin, renvoyer le mot ainsi formé }

---

J'en ai déjà fait beaucoup trop, mais c'est pour que tu comprennes le principe des tableaux dynamiques !
D'ailleurs, il te reste encore à faire la concaténation de deux mots, et d'un mot avec un symbole avant. Ce qui te permettra de pratiquer, pour ne pas oublier. ;)

@Trademark:
"Et surtout, ton professeur aurait prévu une fonction "copier" dans les prototypes donnés."
Pas forcément : premièrement, les symboles utilisés sont des POD, donc pas besoin de fonction spéciale ; et deuxièmement, le C++ dispose d'une merveille appellée constructeur de copie pour le cas de symboles plus complexes (ce qui n'est pas le cas ici).

Toujours est-il que cet énoncé me semble avoir une grosse erreur de conception, de par le fait qu'il ne passe que des pointeurs, alors que si de pointeur il y avait le besoin (symbole lourd), il pourrait être géré directement par la structure.
Et je ne parle même pas des embrouilles d'appartenance des pointeurs passés. (Est-ce que la fonction "singleton" (au mauvais nom par ailleurs) doit transférer la responsabilité du symbole au mot ou non ? Le const semble faire comprendre que non, mais étant donné les pointeurs de partout ...)

"singleton->symboles = new(symbole); // Allocation de la "chaine" de symbole, ici 1 symbole."
Sauf que, pour déclarer un tableau, autant le faire proprement :
"singleton->symboles = new symbole[1];"
Et autant le faire de façon propre avec une std::string. Le problème étant alors que ce n'est pas possible en restant dans le domaine strict de l'exercice ("aucune fonction externe") ...

Citation:

---

Envoyé par Equinoxe_

@Trademark:
"Et surtout, ton professeur aurait prévu une fonction "copier" dans les prototypes donnés."
Pas forcément : premièrement, les symboles utilisés sont des POD, donc pas besoin de fonction spéciale ; et deuxièmement, le C++ dispose d'une merveille appellée constructeur de copie pour le cas de symboles plus complexes (ce qui n'est pas le cas ici).

---

A vrai dire, ce n'est pas du C++ qu'il fait, mais du C auquel on rajoute l'overloading. Dans les universités, et c'est encore plus vrai quand ce n'est pas une section info, la plupart des professeurs ne savent pas coder proprement.

Vu que ce n'est pas pas du C++, les classes sont proscrites, donc exit le constructeur de copie (mais aussi les références dont tu parlais).

Pour ta première remarque, je suis d'accord.

Malgré tout, vu qu'il y le spécificateur "const" et surtout le pointeur, à mon sens, la fonction n'a pas la responsabilité de copier l'objet... Sinon comme tu l'as dit, on aurait pu supprimer le pointeur...

De toute manière, un symbole ne devrait même pas être une structure mais juste un typedef...

Enfin il faut faire avec les règles indiquées, donc je pense que c'est plus la peine de dire "il aurait pu".

Je reviendrai juste sur deux points, étant d'accord sur tout le reste.

Citation:

---

Envoyé par Trademark

[...]

Malgré tout, vu qu'il y le spécificateur "const" et surtout le pointeur, à mon sens, la fonction n'a pas la responsabilité de copier l'objet... Sinon comme tu l'as dit, on aurait pu supprimer le pointeur...

De toute manière, un symbole ne devrait même pas être une structure mais juste un typedef...

[...]

---

Pour la copie, et pour faire une analogie avec le C++, le constructeur par copie ne prend-il pas une référence (équivalent pointeur) constant ?
Par ailleurs, il semblerait que le pointeur soit omniprésent pour chaque "mot" ou "symbole" -- y aurait-il une idée de polymorphisme ici ? Cela m'étonnerait, étant donné la description que tu fais de ce type de professeur.

Pour le typedef, pas forcément.
Il serait envisageable d'utiliser une forward-declaration avec "struct symbole;", ce qui serait impossible avec un typedef, qui, lui, obligerait à augmenter les dépendances du header.
C'est surtout vrai si on suppose un "symbole" plus complexe, par exemple std::ofstream. (Bon, j'admets, cela n'aurait pas grand sens, mais bon ...)
Parce qu'être obligé d'include fstream, ce n'est pas forcément intéressant.
J'admets, je choisis des mauvais exemples, mais l'idée reste là.

Citation:

---

Envoyé par Equinoxe_

Pour la copie, et pour faire une analogie avec le C++, le constructeur par copie ne prend-il pas une référence (équivalent pointeur) constant ?

---

Je suis d'accord. Par contre attention à ne pas trop généraliser, une référence ce n'est pas pareil qu'un pointeur.

Citation:

---

Envoyé par Equinoxe_

Par ailleurs, il semblerait que le pointeur soit omniprésent pour chaque "mot" ou "symbole" -- y aurait-il une idée de polymorphisme ici ? Cela m'étonnerait, étant donné la description que tu fais de ce type de professeur.

Pour le typedef, pas forcément.
Il serait envisageable d'utiliser une forward-declaration avec "struct symbole;", ce qui serait impossible avec un typedef, qui, lui, obligerait à augmenter les dépendances du header.
C'est surtout vrai si on suppose un "symbole" plus complexe, par exemple std::ofstream. (Bon, j'admets, cela n'aurait pas grand sens, mais bon ...)
Parce qu'être obligé d'include fstream, ce n'est pas forcément intéressant.
J'admets, je choisis des mauvais exemples, mais l'idée reste là.

---

Effectivement, il ne faut pas aller chercher trop loin, du polymorphisme m'étonnerait beaucoup.

Pour ce qui est du typedef, j'avoue que ta réflexion est juste et que je ne m'en était pas rendu compte. Mais, parce qu'il y a toujours matière à argumenter, dans le cadre de ce projet, je doute qu'il y ait beaucoup de dépendance :)

Enfin j'ai peur que l'initiateur du message ne comprenne pas tout ce qu'on vient de dire, s'il revient parmi nous. :mouarf:

Bonjour,

Merci pour vos réponses... très... complètes... Je n'ai pas tout compris en effet... :mrgreen: Mais ça m'a aidé!

Sachant que j'ai défini ma structure mot comme ceci:

Code:

---

1 2 3

struct mot { const symbole* symboles[]; };

---

J'ai donc fait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

mot* mot_vide(void) { mot* movid = new mot; movid->symboles[0] = new symbole; movid->symboles[0] = 0; return movid; }     mot* singleton(symbole const* a) { mot * sing = new mot; sing->symboles[1] = new symbole; sing->symboles[1] = a; return sing; }     unsigned int longueur(mot const* a) { return (sizeof(a)-1);   }

---

ça à l'air de bien marcher vu j'ai des points dans le système automatique de notation...

Seulement, j'ai un problème dans la fonction récupérer:

Code:

---

1 2 3 4

symbole const* recuperer(mot const* a , unsigned int b) { return a->symboles[b]; }

---

J'ai une erreur de segmentation alors que pour moi, cette commande va récupérer le b-ième symbole dans a.

Merci pour votre patience! :aie:

C'est normal, c'est au moment de l'initialisation que ça ne fonctionne pas.

Ce devrait être movid->symboles = NULL; pour le mot vide, et movid->symboles = new symbole[1]; *movid->symboles[0] = *a pour le mot "singleton".

Explications : Pour le premier bout de code, ça dit de ne pas réserver de place. Ce qui est normal, car on n'a pas envie de stocker quoi que ce soit !
Pour le second, il réserve de la place pour un symbole (le [1]). Puis il dit de copier a dans movid->symboles[0];, qui est le premier élément de symboles.

Au passage, il faudrait que tu revoies la façon d'indexer un tableau. ;)

Enfin, il serait nécessaire de stocker aussi un champ longueur dans la structure symbole, car sinon ça ne fonctionnera pas pour la suite, car tu n'auras aucun moyen de connaître la longueur d'un mot.

Citation:

---

Envoyé par Equinoxe_

Ce devrait être movid->symboles = NULL; pour le mot vide, et movid->symboles = new symboles[1]; *movid->symboles[0] = *a pour le mot "singleton".

---

Merci de m'aider mais tu mélanges toutes les notations donc j'ai encore un peu plus de mal à comprendre... Attention à la différence entre symbole et symboleS...

En effet, j'ai fait une typo : j'ai mis new symboles au lieu de new symbole.
Je corrige tout de suite !

Pour comprendre ce que dit Equinoxe, pose toi la question suivante :

Les retours de tes fonctions de création de mot sont de type "mot*". Comment afficher un mot ?

Pour cela, il faut savoir sa longueur exacte ! Mais tu ne la connais pas.

Par exemple ta fonction longueur n'est pas bonne :

Code:

---

1 2 3 4

unsigned int longueur(mot const* a) { return (sizeof(a)-1); }

---

Tu demandes à sizeof la taille du mot a, donc du type "mot*", et comme tout pointeur, "mot*" a une taille de 8 auquel tu soustrais 1, donc ta fonction retourne 7 dans tous les cas ! Fait toi même le test pour te convaincre.

Pour connaitre la taille d'un mot, tu as 2 solutions :

1. Soit comme Equinoxe l'a dit, ajouter un champ longueur dans la structure d'un mot.
2. Soit t'inspirer du système des char*, à savoir toute chaine de caractère se termine par le caractère '\0'. Donc toi tu pourrais dire : toute chaine de pointeur de symbole se termine par le pointeur de symbole NULL.

Dans le deuxième cas, pour connaitre la taille, il faut parcourir tout le tableau jusqu'à ce que tu rencontres le pointeur NULL qui t'indique la fin de la chaine.

Exemple avec le singleton :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

mot* singleton(symbole const* a) { mot* s = new mot; s->symboles = new symbole* [2]; // On reserve la place pour un pointeur vers un symbole + le caractère de fin NULL.   s->symboles[0] = a; // Le symbole n'est pas copié !! Les deux pointeurs (à savoir a et s->symboles[0] pointerons vers le même symbole).   // OU EN COPIANT 'a' (cf. Equinoxe) *(s->symboles[0]) = *a;   s->symboles[1] = NULL; // Le caractère de fin. return s; }

---

Pour t'aider à comprendre voici comment tu peux compter :

Code:

---

1 2 3 4 5 6 7 8 9

size_t longueur(mot const* m) { size_t taille; // size_t est pareil que unsigned long int, mais c'est plus clair de l'utiliser quand c'est explicitement une taille qu'on veut stocker.   for(taille = 0; m->symboles[taille] != NULL; ++taille) ; // <== Note le ';' : la boucle ne contient pas d'instruction. // Tant que un pointeur n'est pas égal à NULL, on a pas atteint la fin.   return taille; }

---

Comme tu vois, tu dois parcourir toute la chaine de symbole pour connaitre sa taille... Si tu stockes la valeur 'longueur' dans la structure, alors tu connais la taille directement sans devoir tout parcourir.

Bonne continuation.

PS : n'hésite pas à consulter la FAQ pour ces histoires d'allocations.

Citation:

---

Envoyé par Equinoxe_

Ce devrait être movid->symboles = NULL; pour le mot vide, et sing->symboles = new symbole[1]; *sing->symboles[0] = *a pour le mot "singleton".

---

La définition de la structure selon toi serait:

Code:

---

1 2 3 4

struct mot { const symbole* symboles; unsigned int lon; };

---

et donc on aurait:

Code:

---

1 2 3 4 5 6 7

mot* singleton(symbole const* a) { mot * sing = new mot; sing->symboles = new symbole[1]; *(sing->symboles[0]) = *a; return sing; }

---

Ici, je debug et j'ai " error: no match for 'operator*' in '**sing->mot::symboles' " ...

De plus, lorsque je mets " NULL " j'ai: NULL was not declared in this scope " ...

Merci!

Citation:

---

Envoyé par Guillaume1989

Code:

---

1 2 3 4

struct mot { const symbole** symboles; unsigned int lon; };

---

---

C'est un tableau de pointeur et pas un simple tableau.

Citation:

---

Envoyé par Guillaume1989

De plus, lorsque je mets " NULL " j'ai: NULL was not declared in this scope " ...

Merci!

---

Il faut inclure un header, soit iostream, ou alors cstdlib.

Et essaye de respecter ce qu'on te dit, notamment au niveau du nom des variables, le champ "lon" ne veut rien dire. Privilégie "longueur" ou "taille" par exemple... Pareil pour "sing" (chanter ?) ou movid (move id ?), comme tu vois on peut facilement confondre.

Je ne comprends plus rien là...

Je ne sais plus quelle structure va avec quelle façon de déclarer... Et aucune ne résout mes problèmes de segmentation...

Code:

---

1 2 3 4 5

struct mot { const symbole** symboles; unsigned int taille; };

---

Bien avec deux étoiles car on a un tableau de pointeur et sans crochet après symboles, correct?

Ainsi, mes déclarations deviennent:

Code:

---

1 2 3 4 5 6 7 8

mot* mot_vide(void) { mot* motvide = new mot; motvide->symboles = new symbole * [1]; motvide->symboles[0] = NULL; motvide->taille = 0; return motvide; }

---

Code:

---

1 2 3 4 5 6 7 8 9

mot* singleton(symbole const* a) { mot* s = new mot; s->symboles = new symbole* [2]; // Places pour deux nouveaux symboles. *(s->symboles[0]) = *a; // On copie a dans l'emplacement 0. s->symboles[1] = NULL; // Le caractère de fin. s->taille = 1; return s; }

---

Correcte ou pas?

Ensuite, pour le NULL qui ne marche pas et l'utilisation d'un header... Je n'ai pas le droit de mettre des header car ils sont inclus dans le fichier de test. Je mets '\0' du coup?

Merci.

Faut pas mélanger les 2 techniques exposées. Soit tu utilises un symbole de fin (NULL), soit tu stockes la taille.

Bon disons que tu stockes la taille, alors ta déclaration est bonne.

Code:

---

1 2 3 4 5 6 7 8 9 10

#define NULL 0   mot* mot_vide(void) { mot* motvide = new mot; motvide->symboles = NULL; motvide->taille = 0; return motvide; }

---

Code:

---

1 2 3 4 5 6 7 8 9

mot* singleton(symbole const* a) { mot* s = new mot; s->symboles = new symbole* [1]; // Places pour un nouveau pointeur de symbole. *(s->symboles[0]) = *a; // On copie a dans l'emplacement 0. s->taille = 1; return s; }

---

Et voila le travail ;)

Par contre si tu fais une copie, je ne vois pas l'intérêt du double pointeur. Tu peux simplifier le tout en faisant comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#define NULL 0   typedef struct mot { const symbole* symboles; unsigned int taille; }mot;   mot* mot_vide(void) { mot* motvide = new mot; motvide->symboles = NULL; motvide->taille = 0; return motvide; } mot* singleton(symbole const* a) { mot* s = new mot; s->symboles = new symbole[1]; // à la place de new symbole*[1] s->symboles[0] = *a; // à la place de *(s->symboles[0]) = *a; s->taille = 1; return s; }

---

J'ai recopié la deuxième version, je debug, je me retrouve avec environ 12 erreurs. Ça sert à quoi les <s> ?!

Vu la correction!

Concernant la ligne 19 de ton message précédent, j'ai l’erreur suivante:

"error: passing 'const symbole' as 'this' argument of 'symbole& symbole::operator=(const symbole&)' discards qualifiers"

Les <s> c'était pcq je voulais mettre une balise mais elle n'a pas été prise en compte dans la balise CODE.

Ensuite :

Code:

---

1 2 3 4

typedef struct mot { symbole* symboles; unsigned int taille; }mot;

---

Bonjour,

Tout ça fonctionne mieux! :ccool: Merci!

Pourquoi il fallait mettre 'typedef'?

Ce qui a surtout fait compilé ton programme c'est la suppression du mot clé "const" ;)

Le typedef permet de déclarer une variable mot avec le type "mot" au lieu de "struct mot" qui est plus long. C'est donc juste un raccourci.

EDIT : Voir le post d'Equinoxe ci-dessous... c'est en C pur que le typedef est nécessaire...

Citation:

---

Envoyé par Trademark

Ce qui a surtout fait compilé ton programme c'est la suppression du mot clé "const" ;)

Le typedef permet de déclarer une variable mot avec le type "mot" au lieu de "struct mot" qui est plus long. C'est donc juste un raccourci.

---

En C++, le typedef est inutile. ;)