Discussion :

[emmesse]

Bonjour,

sur la capture d'écran, on voit p[1]="epsilon" et l'instruction de la ligne 273 du if se fait quand-même alors que la condition n'est pas vérifiée

j'utilise le deboggeur gdb

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
25
26
27
28
29
30
31
32
33
34
35
36
void grammaire::recursdirecte(std::string A){
  std::vector<std::vector<std::string>>retour;
  std::vector<std::string> X,Y;
  bool premieralpha=true;
  size_t indice=0;
  for(auto &p:grammaire_s)
    if(p[0]==A){
      if(p[1]==A)
	if( ! annulable(A) && premieralpha){
	  Y.push_back(A+"prim");
	  Y.push_back("epsilon");
	  retour.push_back(Y);
	  Y.clear();
	  premieralpha=false;
	}
	X.push_back(A+"prim");
	X.insert(X.end(),p.begin()+2,p.end());//alpha_n
	X.push_back(A+"prim");
	retour.push_back(X);
	X.clear();
      }
      else{
	X.push_back(A);
	if(p[1] != "epsilon")
	  X.insert(X.end(),p.begin()+1,p.end());//beta_n
	X.push_back(A+"prim");
	retour.push_back(X);
	X.clear();
      }
  for(size_t i=0;i<grammaire_s.size();i++)
    if(grammaire_s[i][0]==A){
      grammaire_s.erase(grammaire_s.begin()+i);
      i--;
    }
  grammaire_s.insert(grammaire_s.end(),retour.begin(),retour.end());
}

quelqu'un a une idée?

[emmesse]

c'est parce que j'ai compilé comme ça:

Code :

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

g++ -g -o direct *cpp

puis:

Code :

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

gdb --args ./a.out a-sa

du coup, le fichier source ne correspondait pas

[deedolith]

Salut,

Il va vraiment falloir que tu te mettes à écrire du code qui veuille dire quelque chose, à commencer par choisir des noms de variables pertinents.
Sérieusement, A, X, Y, P, ca ne veut rien dire, et Retour encore moins (ta fonction ne retourne rien).

De plus, en C++, on ne pré-déclare pas les variables, ca gaspille des ressources inutilement (aussi infimes soient-elles).
On déclare les variable là où on les utilises pour la première fois (et on les initialise au passage).

[emmesse]

@deedolith

il n'y a pas vraiment de retour, le résultat vient s'ajouter à grammaire_s

-------------------
une autre fonction, Rproductions
il faut donc que je redéclare la variable Rproductions_s à chaque scope du if-else?
et si je la déclarais avant le if?

version1:

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
25
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::Rproductions(std::vector<std::vector<std::string>> const &Rproductions_h){
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>Rproductions1_h;
    Rproductions1_h=Rproductions_h;
    Rproductions1_h.insert(Rproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>Rproductions1_s;
    Rproductions1_s=Rproductions(Rproductions1_h);
    std::vector<std::vector<std::string>>Rproductions_s;
    Rproductions_s=Rproductions1_s;
    return Rproductions_s;
  }
  else{
    std::vector<std::vector<std::string>>Rproductions_s;
    Rproductions_s=Rproductions_h;
    return Rproductions_s;
  }
}

version 2:

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
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::Rproductions(std::vector<std::vector<std::string>> const &Rproductions_h){
  std::vector<std::vector<std::string>>Rproductions_s;
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>Rproductions1_h;
    Rproductions1_h=Rproductions_h;
    Rproductions1_h.insert(Rproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>Rproductions1_s;
    Rproductions1_s=Rproductions(Rproductions1_h);
    Rproductions_s=Rproductions1_s;
    return Rproductions_s;
  }
  else{
    Rproductions_s=Rproductions_h;
    return Rproductions_s;
  }
}

désolé pour le passage des données de vector en vector, mais il faut que ça corresponde au schéma de traduction dirigée par la syntaxe:
(le "+" est la concaténation)

Code :

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

1
2
Rproductions	→ productions { Rproductions1.h= Rproductions.h + productions.s } Rproductions1 { Rproductions.s = Rproductions1.s }
		→ ε { Rproductions.s = Rproductions.h }

merci pour ton aide

[deedolith]

Toujours les mêmes reproches:
Ton code n'a de sens que pour toi.

Si tu veux faire du C++, Fait du C++.
Pas de la cuisine de camping sous-étoilé comme ce que tu nous montres jusqu'à présent.

[emmesse]

et 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
23
24
25
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::resteproductions(std::vector<std::vector<std::string>> const &resteproductions_h){
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>resteproductions1_h;
    resteproductions1_h=resteproductions_h;
    resteproductions1_h.insert(resteproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>resteproductions1_s;
    resteproductions1_s=resteproductions(resteproductions1_h);
    std::vector<std::vector<std::string>>resteproductions_s;
    resteproductions_s=resteproductions1_s;
    return resteproductions_s;
  }
  else{
    std::vector<std::vector<std::string>>resteproductions_s;
    resteproductions_s=resteproductions_h;
    return resteproductions_s;
  }
}

peut-être qu'il faut savoir ça pour comprendre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
grammaire	→ productions { Rproductions.h = productions.s} Rproductions fin { grammaire.s = Rproductions.s*; grammaire.axiome=grammaire.s[0][0] }
fin	→ fdf | linefeed | ε
Rproductions	→ productions { Rproductions1.h= Rproductions.h + productions.s } Rproductions1 { Rproductions.s = Rproductions1.s }
		→ ε { Rproductions.s = Rproductions.h }
productions	→ mot { ensembleprods.tete = mot.s } fleche ensembleprods linefeed { productions.s = ensembleprods.s }
ensembleprods	→ {production.tete = ensembleprods.tete } production { Rprod.h ||= production.s*; Rprod.tete = ensembleprods .tete } Rprod { ensembleprods.s = Rprod.s }
Rprod	→ barre { production.tete = Rprod.tete } production { Rprod1.h = Rprod.h || production.s*; Rprod1.tete = Rprod.tete } Rprod1 { Rprod.s = Rprod1.s }
	→ ε { Rprod.s = Rprod.h }
production	→ mot { restecorps.h ||= mot.s } restecorps { production.s ||= production.tete*; production.s += restecorps.s }
restecorps	→ mot { restecorps1.h = retecorps.h || mot.s } restecorps1 { restecoprs.s = restecorps1.s }
		→ ε { restecorps.s = restecorps.h }

sinon, dis-moi où exactement tu ne comprends pas...