Discussion :

[Trademark]

Bonsoir!
Merci pour la réponse!

NULL ne fonctionne pas.

Pourquoi dis-tu ça ?

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Ekleog]

@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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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") ...

[Trademark]

@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".

[Ekleog]

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

[...]

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à.

[Trademark]

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.

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.

[Guillaume1989]

Bonjour,

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
struct mot {
  const symbole* symboles[];
};

J'ai donc fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[Ekleog]

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.

[Guillaume1989]

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...

[Ekleog]

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

[Trademark]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Guillaume1989]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct mot {
  const symbole* symboles;
  unsigned int lon;
};

et donc on aurait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[Trademark]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct mot {
  const symbole** symboles;
  unsigned int lon;
};

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

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.

[Guillaume1989]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Trademark]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[Guillaume1989]

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

Vu la correction!

[Guillaume1989]

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"

[Trademark]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct mot {
  symbole* symboles;
  unsigned int taille;
}mot;

[Guillaume1989]

Bonjour,

Tout ça fonctionne mieux! Merci!

Pourquoi il fallait mettre 'typedef'?

[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.

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

[Ekleog]

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.