classe enregistrement ne compile pas

Version imprimable

bonjour à tous

je ne comprend pas pourquoi il refuse ma classe enregistrement (je ne connais pas bien shared_ptr)

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
enregistrements.hpp
#ifndef enregistrements_hpp
#define enregistrements_hpp
 
#include "commun.hpp"
 
#include <string>
#include <vector>
enum class type{Taction,Tterminal,TnonTerminal,Tsynthese};
enum class typeSynthese{synthC,synthA1,synthAprim,synthA2,
			synthB,synthBprim};
 
class enregistrement{
public:
  virtual void affiche();
  virtual type quelType();
  virtual int getActionSemantique();
  virtual void setActionSemantique(int const &x);
  virtual SYMBOLE getSymbole();
  virtual void setSymbole(SYMBOLE const &x);
  virtual bool vaut(ULEX const &a);
  virtual bool estTerminal();
  virtual void ajoute(std::string const &x);
  virtual typeSynthese getNomSynthese();
  virtual void setNomSynthese(typeSynthese const &x);
};
 
class action:public enregistrement{
public:
  void affiche();
  type quelType();// retourne toujours Taction
  std::string getA(int const &i);
  void setA(int const &i,std::string const &x);
  void ajoute(std::string const &x);
  int getActionSemantique();
  void setActionSemantique(int const &x);
private:
  int actionSemantique;
  std::vector<std::string> Attr;
};
 
class terminal:public enregistrement{
public:
  void affiche();
  type quelType();// retourne toujours Tterminal
  bool vaut(ULEX const &a);
  bool estTerminal();//retourne toujours true
  int getActionSemantique();//retourne toujours 0
  void setSymbole(SYMBOLE const &x);
  SYMBOLE getSymbole();
  std::string symbole2string();
private:
  SYMBOLE X;
  ULEX term;
};
 
class nonTerminal:public enregistrement{
public:
  void affiche();
  type quelType();// retourne toujours TnonTerminal
  void setSymbole(SYMBOLE const &x);
  SYMBOLE getSymbole();
  int getActionSemantique();//retourne toujours 0
  std::string getHerite(int i);
  void setHerite(int const &i,std::string const &x);
  void ajoute(std::string const &x);
  bool estTerminal();//retourne toujours false;
  std::string symbole2string();
private:
  SYMBOLE X;
  std::vector<std::string>herite;
};
 
class synthese:public enregistrement{
public:
  void affiche();
  type quelType();// retourne toujours Tsynthèse
  typeSynthese getNomSynthese();
  void setNomSynthese(typeSynthese const &x);
  std::string getA(int i);
  void setA(int const &i,std::string const &x);
  void ajoute(std::string const &x);
  int getActionSemantique();
  void setActionSemantique(int const &x);
  std::string symbole2string();
private:
  std::vector<std::string>Attr;
  int actionSemantique;
  typeSynthese nomSynthese;
};
#endif

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
syntaxique.cpp
#include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::shared_ptr<enregistrement>E;
  E=std::make_shared<enregistrement>(new terminal);
  E->setSymbole(SYMBOLE::dolar);
  pile.push_back(E);
  E=std::make_shared<enregistrement>(new nonTerminal);
  E->setSymbole(SYMBOLE::C);
  pile.push_back(E);
  E=std::make_shared<enregistrement>(new synthese);
  E->setNomSynthese(typeSynthese::synthC);
  E->ajoute("");
  E->ajoute("");
  pile.push_back(E);
}
 
void syntaxique::anaSynt(){
  uniLex l;
  l=pe.anaLex();
  a=l.getLex();
  X=std::make_shared<enregistrement>(pile[pile.size()-1]);
  while( ! X->vaut(ULEX::dolar)){
    if(X->vaut(a)){
      pile.pop_back();
      l=pe.anaLex();
      a=l.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<l.getLexeme()<<" inattendu"<<std::endl;
	l=pe.anaLex();
	a=l.getLex();
      }
    switch(X->getSymbole()){
    case SYMBOLE::C:
      if(a==ULEX::a){
	//inachevé
      }
    }
  }
}

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
$ g++ -c syntaxique.cpp
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = enregistrement; _Args = {terminal*}; _Tp = enregistrement]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = enregistrement; _Args = {terminal*}; _Tp = enregistrement; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<enregistrement>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {terminal*}; _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {terminal*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {terminal*}; _Tp = enregistrement; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {terminal*}; _Tp = enregistrement]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {terminal*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = enregistrement; _Args = {terminal*}]’
syntaxique.cpp:8:50:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘enregistrement::enregistrement(terminal*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement()’
   12 | class enregistrement{
      |       ^~~~~~~~~~~~~~
enregistrements.hpp:12:7: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(const enregistrement&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘terminal*’ to ‘const enregistrement&’
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(enregistrement&&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘terminal*’ to ‘enregistrement&&’
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = enregistrement; _Args = {nonTerminal*}; _Tp = enregistrement]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = enregistrement; _Args = {nonTerminal*}; _Tp = enregistrement; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<enregistrement>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {nonTerminal*}; _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {nonTerminal*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {nonTerminal*}; _Tp = enregistrement; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {nonTerminal*}; _Tp = enregistrement]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {nonTerminal*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = enregistrement; _Args = {nonTerminal*}]’
syntaxique.cpp:11:53:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘enregistrement::enregistrement(nonTerminal*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement()’
   12 | class enregistrement{
      |       ^~~~~~~~~~~~~~
enregistrements.hpp:12:7: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(const enregistrement&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘nonTerminal*’ to ‘const enregistrement&’
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(enregistrement&&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘nonTerminal*’ to ‘enregistrement&&’
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = enregistrement; _Args = {synthese*}; _Tp = enregistrement]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = enregistrement; _Args = {synthese*}; _Tp = enregistrement; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<enregistrement>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {synthese*}; _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {synthese*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {synthese*}; _Tp = enregistrement; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {synthese*}; _Tp = enregistrement]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {synthese*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = enregistrement; _Args = {synthese*}]’
syntaxique.cpp:14:50:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘enregistrement::enregistrement(synthese*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement()’
   12 | class enregistrement{
      |       ^~~~~~~~~~~~~~
enregistrements.hpp:12:7: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(const enregistrement&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘synthese*’ to ‘const enregistrement&’
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(enregistrement&&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘synthese*’ to ‘enregistrement&&’
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = enregistrement; _Args = {std::shared_ptr<enregistrement>&}; _Tp = enregistrement]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = enregistrement; _Args = {std::shared_ptr<enregistrement>&}; _Tp = enregistrement; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<enregistrement>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {std::shared_ptr<enregistrement>&}; _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {std::shared_ptr<enregistrement>&}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {std::shared_ptr<enregistrement>&}; _Tp = enregistrement; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<enregistrement>; _Args = {std::shared_ptr<enregistrement>&}; _Tp = enregistrement]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = enregistrement; _Alloc = std::allocator<enregistrement>; _Args = {std::shared_ptr<enregistrement>&}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = enregistrement; _Args = {std::shared_ptr<enregistrement>&}]’
syntaxique.cpp:25:57:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘enregistrement::enregistrement(std::shared_ptr<enregistrement>&)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement()’
   12 | class enregistrement{
      |       ^~~~~~~~~~~~~~
enregistrements.hpp:12:7: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(const enregistrement&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘std::shared_ptr<enregistrement>’ to ‘const enregistrement&’
enregistrements.hpp:12:7: note: candidate: ‘constexpr enregistrement::enregistrement(enregistrement&&)’
enregistrements.hpp:12:7: note:   no known conversion for argument 1 from ‘std::shared_ptr<enregistrement>’ to ‘enregistrement&&’

quelqu'un a une idée?

24/03/2020, 00h45
Invité
Bonsoir,

Ton problème vient des lignes où tu utilises std::make_shared. Les paramètres que tu passes à cette fonction sont transmis au constructeur du type spécifié en paramètre template.
std::make_shared<Classe>(/* paramètres */) appelle en interne new Classe(/* ces mêmes paramètres std::forward-és */).

Autrement dit ici, lorsque tu écris std::make_shared<enregistrement>(new terminal);, elle appelle en interne new enregistrement(/* un pointeur sur terminal */), et donc :
- tu ne crées pas un pointeur sur un terminal, mais sur un enregistrement ;
- tu passes le pointeur new terminal au constructeur de la classe enregistrement,
et ta classe enregistrement n'ayant aucun constructeur avec un terminal* en paramètre, tu te retrouves avec ce message d'erreur, en particulier :

Citation:

error: no matching function for call to ‘enregistrement::enregistrement(terminal*)’

Ta ligne se corrige donc en :

Code:

X = std::make_shared<terminal>();

Même chose avec nonTerminal et synthese.

En ce qui concerne le dernier X=std::make_shared<enregistrement>(pile[pile.size()-1]);, là tu passes un carrément un std::shared_ptr<enregistrement> au constructeur.
Pourquoi chercher à en créer un nouveau ? Alors que tu as juste à manipuler l'existant :

Code:

auto const & X = pile[pile.size()-1]; // ou pile.back();

Quelques conseils pour finir :
- marque const les fonctions membre qui ne modifient pas les membres ;
- ajoute override aux fonctions membre virtuelles que tu redéfinis dans les classes enfants ;
- classe de base d'une hiérarchie :arrow: destructeur virtuel, suppression constructeur/opérateur d'affectation par copie (sémantique d'entité) qui t'évitera des fuites et problèmes de slicing ;
- utilise des noms de variable plus parlants qu'une seule lettre.

merci pour la réponse
dans la pile, on a une collection hétérogène d'enregistrements (action,synthèse,terminal et nonTerminal)
on ne sait pas ce que l'on va trouver au sommet de cette pile, c'est pourquoi j'ai utilisé "enregistrement".
je voulais un pointeur E qui pointe, selon le somment de la pile, vers un objet d'une classe fille d'enregistrement (action, synthèse, terminal ou nonTerminal)
devrais-je définir la pile comme ça:

Code:

std::vector <enregistrement*>pile

ou bien:

Code:

std::vector<std::shared_ptr<enregistrement>> pile;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #ifndef SYNTAXIQUE_HPP #define SYNTAXIQUE_HPP #include <vector> #include <string> #include <memory> #include "lexical.hpp" #include "commun.hpp" #include "enregistrements.hpp" class syntaxique{ public: syntaxique(std::string const& nomFichier); void anaSynt(); private: lexical pe; std::vector<std::shared_ptr<enregistrement>> pile; void exec(int const &x); std::shared_ptr<enregistrement>X; ULEX a; }; #endif
sinon, peux-tu m'en dire plus sur "overide"?

voici enregistrements.cpp qui compile très bien

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#include <iostream>
#include <string>
 
#include "enregistrements.hpp"
 
action::action(){}
 
void action::affiche()const{
  std::cout<<"-----"<<std::endl
	   <<"action"<<std::endl;
  for(int i=0;i<Attr.size();i++)
    std::cout<<Attr[i]<<std::endl;
  std::cout<<"-----"<<std::endl;
}
 
type action::quelType()const{
  return type::Taction;
}
 
std::string action::getA(int const &numAttr)const{
  return Attr[numAttr];
}
 
void action::ajoute(std::string const &numDonneeAction){
  Attr.push_back(numDonneeAction);
}
 
int action::getActionSemantique()const{
  return actionSemantique;
}
 
void action::setActionSemantique(int const &numAction){
  actionSemantique=numAction;
}
 
terminal::terminal(){}
 
void terminal::affiche()const{
  std::cout<<"-----"<<std::endl
	   <<symbole2string()<<std::endl
	   <<"-----"<<std::endl;
}
 
type terminal::quelType()const{
  return type::Tterminal;
}
 
bool terminal::vaut(ULEX const &a)const{ /*l'identificateur "a" est indiqué
					   ainsi dans le dragonbook, qui est
					   l'unité lexical lu*/
  return (int)X==(int)a;//ainsi que X, qui est le sommet de la pile
}
 
bool terminal::estTerminal()const{
  return true;
}
 
int terminal::getActionSemantique()const{
  return 0;
}
 
void terminal::setSymbole(SYMBOLE const &x){ //mutateur de X
  X=x;
}
 
SYMBOLE terminal::getSymbole()const{
  return X;
}
 
std::string terminal::symbole2string()const{
  std::string convert;
  switch(X){
  case SYMBOLE::a:
    convert="a";
    break;
  case SYMBOLE::b:
    convert="b";
    break;
  case SYMBOLE::sep:
    convert="sep";
    break;
  case SYMBOLE::dolar:
    convert="$";
    break;
  }
  return convert;
}
 
nonTerminal::nonTerminal(){}
 
void nonTerminal::affiche()const{
  std::cout<<"-----"<<std::endl
	   <<symbole2string()<<std::endl;
  for(int i=0;i<herite.size();i++)
    std::cout<<herite[i]<<std::endl;
  std::cout<<"-----"<<std::endl;
}
 
type nonTerminal::quelType()const{
  return type::TnonTerminal;
}
 
void nonTerminal::setSymbole(SYMBOLE const &x){
  X=x;
}
 
int nonTerminal::getActionSemantique()const{
  return 0;
}
 
std::string nonTerminal::getHerite(int numAttr)const{
  return herite[numAttr];
}
 
void nonTerminal::setHerite(int const &numAttr,
			    std::string const &valAttr){
  herite[numAttr]=valAttr;
}
 
void nonTerminal::ajoute(std::string const &valAttr){
  herite.push_back(valAttr);
}
 
bool nonTerminal::estTerminal()const{
  return false;
}
 
std::string nonTerminal::symbole2string()const{
  std::string convert;
  switch(X){
  case SYMBOLE::C:
    convert="C";
    break;
  case SYMBOLE::A:
    convert="A";
    break;
  case SYMBOLE::Aprim:
    convert="A'";
    break;
  case SYMBOLE::B:
    convert="B";
    break;
  case SYMBOLE::Bprim:
    convert="B'";
    break;
  }
  return convert;
}
 
synthese::synthese(){}
 
void synthese::affiche()const{
  std::cout<<"-----"<<std::endl
	   <<"synthèse "<<symbole2string()<<std::endl;
  for(int i=0;i<Attr.size();i++)
    std::cout<<Attr[i]<<std::endl;
}
 
type synthese::quelType()const{
  return type::Tsynthese;
}
 
std::string synthese::getA(int numAttr)const{
  return Attr[numAttr];
}
 
void synthese::setA(int const &numAttr,std::string const &valAttr){
  Attr[numAttr]=valAttr;
}
 
void synthese::ajoute(std::string const &valAttr){
  Attr.push_back(valAttr);
}
 
int synthese::getActionSemantique()const{
  return actionSemantique;
}
 
void synthese::setActionSemantique(int const &numAction){
  actionSemantique=numAction;
}

Code:

1
2
3
4
5
6
7
8
commun.hpp
#ifndef COMMUN_HPP
#define COMMUN_HPP
 
enum class SYMBOLE {a=0,b,sep,dolar,C,A,Aprim,B,Bprim,epsilone};
enum class ULEX {a=0,b,sep,dolar};
 
#endif

j'ai modifié syntaxique.cpp comme suit:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::shared_ptr<terminal>E1;
  std::shared_ptr<nonTerminal>E2;
  std::shared_ptr<synthese>E3;
  E1=std::make_shared<terminal>(new terminal);
  E1->setSymbole(SYMBOLE::dolar);
  pile.push_back(E1);
  E2=std::make_shared<nonTerminal>(new nonTerminal);
  E2->setSymbole(SYMBOLE::C);
  pile.push_back(E2);
  E3=std::make_shared<synthese>(new synthese);
  E3->setNomSynthese(typeSynthese::synthC);
  E3->ajoute("");
  E3->ajoute("");
  pile.push_back(E3);
}
 
void syntaxique::anaSynt(){
  uniLex lu;
  lu=pe.anaLex();
  a=lu.getLex();/*"a" est indiqué ainsi dans le dragonbook, 
		  c'est l'unité lexicale lu par l'analyseur lexical*/
  auto const & X = pile[pile.size()-1];
  while( ! X->vaut(ULEX::dolar)){// X, aussi comme a. Sommet de la pile
    if(X->vaut(a)){
      pile.pop_back();
      lu=pe.anaLex();
      a=lu.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<lu.getLexeme()<<" inattendu"<<std::endl;
	lu=pe.anaLex();
	a=lu.getLex();
      }
    switch(X->getSymbole()){
    case SYMBOLE::C:
      if(a==ULEX::a){
	//inachevé
      }
    }
  }
}

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
$ g++ -c syntaxique.cpp
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = terminal; _Args = {terminal*}; _Tp = terminal]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = terminal; _Args = {terminal*}; _Tp = terminal; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<terminal>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {terminal*}; _Tp = terminal; _Alloc = std::allocator<terminal>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = terminal; _Alloc = std::allocator<terminal>; _Args = {terminal*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<terminal>; _Args = {terminal*}; _Tp = terminal; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<terminal>; _Args = {terminal*}; _Tp = terminal]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = terminal; _Alloc = std::allocator<terminal>; _Args = {terminal*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = terminal; _Args = {terminal*}]’
syntaxique.cpp:10:45:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘terminal::terminal(terminal*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:46:3: note: candidate: ‘terminal::terminal()’
   46 |   terminal();
      |   ^~~~~~~~
enregistrements.hpp:46:3: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:44:7: note: candidate: ‘constexpr terminal::terminal(const terminal&)’
   44 | class terminal:public enregistrement{
      |       ^~~~~~~~
enregistrements.hpp:44:7: note:   no known conversion for argument 1 from ‘terminal*’ to ‘const terminal&’
enregistrements.hpp:44:7: note: candidate: ‘constexpr terminal::terminal(terminal&&)’
enregistrements.hpp:44:7: note:   no known conversion for argument 1 from ‘terminal*’ to ‘terminal&&’
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = nonTerminal; _Args = {nonTerminal*}; _Tp = nonTerminal]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = nonTerminal; _Args = {nonTerminal*}; _Tp = nonTerminal; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<nonTerminal>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {nonTerminal*}; _Tp = nonTerminal; _Alloc = std::allocator<nonTerminal>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = nonTerminal; _Alloc = std::allocator<nonTerminal>; _Args = {nonTerminal*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<nonTerminal>; _Args = {nonTerminal*}; _Tp = nonTerminal; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<nonTerminal>; _Args = {nonTerminal*}; _Tp = nonTerminal]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = nonTerminal; _Alloc = std::allocator<nonTerminal>; _Args = {nonTerminal*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = nonTerminal; _Args = {nonTerminal*}]’
syntaxique.cpp:13:51:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘nonTerminal::nonTerminal(nonTerminal*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:62:3: note: candidate: ‘nonTerminal::nonTerminal()’
   62 |   nonTerminal();
      |   ^~~~~~~~~~~
enregistrements.hpp:62:3: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:60:7: note: candidate: ‘nonTerminal::nonTerminal(const nonTerminal&)’
   60 | class nonTerminal:public enregistrement{
      |       ^~~~~~~~~~~
enregistrements.hpp:60:7: note:   no known conversion for argument 1 from ‘nonTerminal*’ to ‘const nonTerminal&’
enregistrements.hpp:60:7: note: candidate: ‘nonTerminal::nonTerminal(nonTerminal&&)’
enregistrements.hpp:60:7: note:   no known conversion for argument 1 from ‘nonTerminal*’ to ‘nonTerminal&&’
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/c++allocator.h:33,
                 from /usr/include/c++/9/bits/allocator.h:46,
                 from /usr/include/c++/9/memory:63,
                 from syntaxique.cpp:1:
/usr/include/c++/9/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = synthese; _Args = {synthese*}; _Tp = synthese]’:
/usr/include/c++/9/bits/alloc_traits.h:482:2:   required from ‘static void std::allocator_traits<std::allocator<_Tp1> >::construct(std::allocator_traits<std::allocator<_Tp1> >::allocator_type&, _Up*, _Args&& ...) [with _Up = synthese; _Args = {synthese*}; _Tp = synthese; std::allocator_traits<std::allocator<_Tp1> >::allocator_type = std::allocator<synthese>]’
/usr/include/c++/9/bits/shared_ptr_base.h:548:39:   required from ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {synthese*}; _Tp = synthese; _Alloc = std::allocator<synthese>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:679:16:   required from ‘std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = synthese; _Alloc = std::allocator<synthese>; _Args = {synthese*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr_base.h:1344:71:   required from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<synthese>; _Args = {synthese*}; _Tp = synthese; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]’
/usr/include/c++/9/bits/shared_ptr.h:359:59:   required from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<synthese>; _Args = {synthese*}; _Tp = synthese]’
/usr/include/c++/9/bits/shared_ptr.h:701:14:   required from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = synthese; _Alloc = std::allocator<synthese>; _Args = {synthese*}]’
/usr/include/c++/9/bits/shared_ptr.h:717:39:   required from ‘std::shared_ptr<_Tp> std::make_shared(_Args&& ...) [with _Tp = synthese; _Args = {synthese*}]’
syntaxique.cpp:16:45:   required from here
/usr/include/c++/9/ext/new_allocator.h:145:20: error: no matching function for call to ‘synthese::synthese(synthese*)’
  145 |  noexcept(noexcept(::new((void *)__p)
      |                    ^~~~~~~~~~~~~~~~~~
  146 |        _Up(std::forward<_Args>(__args)...)))
      |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from syntaxique.hpp:8,
                 from syntaxique.cpp:3:
enregistrements.hpp:80:3: note: candidate: ‘synthese::synthese()’
   80 |   synthese();
      |   ^~~~~~~~
enregistrements.hpp:80:3: note:   candidate expects 0 arguments, 1 provided
enregistrements.hpp:78:7: note: candidate: ‘synthese::synthese(const synthese&)’
   78 | class synthese:public enregistrement{
      |       ^~~~~~~~
enregistrements.hpp:78:7: note:   no known conversion for argument 1 from ‘synthese*’ to ‘const synthese&’
enregistrements.hpp:78:7: note: candidate: ‘synthese::synthese(synthese&&)’
enregistrements.hpp:78:7: note:   no known conversion for argument 1 from ‘synthese*’ to ‘synthese&&’

une idée?

24/03/2020, 22h04
Invité

Citation:

Envoyé par matser

devrais-je définir la pile comme ça:

Code:

std::vector <enregistrement*>pile

ou bien:

Code:

std::vector<std::shared_ptr<enregistrement>> pile;

De base, je dirais plutôt un std::vector<std::unique_ptr<enregistrement>> à moins que tu aies besoin de partager la responsabilité, auquel cas avec un std::shared_ptr.
(Avec son homologue std::make_unique qui fonctionne de la même manière.)
std::unique_ptr n'étant pas copiable, il faudra faire attention à certaines lignes comme :

Code:

pile.push_back(E1); // copie !

à passer en

Code:

pile.push_back( std::move(E1) ); // déplacement ok

Citation:

Envoyé par matser

sinon, peux-tu m'en dire plus sur "overide"?

(override avec deux « r ».) Cf. ce sujet de FAQ.

Concernant la « nouvelle » erreur, on en revient à mon premier message. std::make_shared effectue elle-même le new. Ce n'est pas à toi de le faire. Et les paramètres d'entrées de la fonction sont transmis au constructeur :

std::make_shared<terminal>(new terminal); => new terminal(new terminal) en interne.

Tes différents constructeurs ne prennent aucun paramètre, donc laisse les parenthèses vides.

merci Winjerome.
je ne savais pas que c'était un appel au constructeur.
j'ai modifié syntaxique.cpp ainsi:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::shared_ptr<terminal>E1;
  std::shared_ptr<nonTerminal>E2;
  std::shared_ptr<synthese>E3;
  E1=std::make_shared<terminal>();
  E1->setSymbole(SYMBOLE::dolar);
  pile.push_back(E1);
  E2=std::make_shared<nonTerminal>();
  E2->setSymbole(SYMBOLE::C);
  pile.push_back(E2);
  E3=std::make_shared<synthese>();
  E3->setNomSynthese(typeSynthese::synthC);
  E3->ajoute("");
  E3->ajoute("");
  pile.push_back(E3);
}
 
void syntaxique::anaSynt(){
  uniLex lu;
  lu=pe.anaLex();
  a=lu.getLex();/*"a" est indiqué ainsi dans le dragonbook, 
		  c'est l'unité lexicale lu par l'analyseur lexical*/
  auto const & X = pile[pile.size()-1];
  while( ! X->vaut(ULEX::dolar)){// X, aussi comme a. Sommet de la pile
    if(X->vaut(a)){
      pile.pop_back();
      lu=pe.anaLex();
      a=lu.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<lu.getLexeme()<<" inattendu"<<std::endl;
	lu=pe.anaLex();
	a=lu.getLex();
      }
    switch(X->getSymbole()){
    case SYMBOLE::C:
      if(a==ULEX::a){
	//inachevé
      }
    }
  }
}

et ça ne fait plus d'erreur, du moins, de compilation. Vu que X recopie le sommet de la pile, sans dépiler, ne suis-je pas obligé d'utiliser shared_ptr?

autre question, pourquoi "const" et "&" dans auto const & X=pile[pile.size() -1], (peut-être & à cause de pointeur?)

une idée?

Salut,

Déjà, dans le cadre présent, tu n'as aucun intérêt à travailler avec des std::shared_ptr, car le seul élément qui puisse effectivement avoir un droit "de vie ou de mort" sur les différents éléments serait la pile de ta classe.

L'utilisation d'un std::unique_ptr serait donc largement plus intéressante, ne serait-ce que pour éviter toute la gestion relative au comptage de référence qu'implique l'utilisation de std::shared_ptr.

De plus, tu devrais prendre l'habitude de déclarer tes variables au plus près de leur première utilisation, ce qui ferait que le constructeur prendrait une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){ std::shared_ptr<terminal>E1=std::make_shared<terminal>(); E1->setSymbole(SYMBOLE::dolar); pile.push_back(E1); std::shared_ptr<nonTerminal>E2=std::make_shared<nonTerminal>(); E2->setSymbole(SYMBOLE::C); pile.push_back(E2); std::shared_ptr<synthese>E3=std::make_shared<synthese>(); E3->setNomSynthese(typeSynthese::synthC); E3->ajoute(""); E3->ajoute(""); pile.push_back(E3); }
En toutre, il serait sans doute utile de modifier le constructeur de tes classes pour éviter d'avoir à appeler ces mutateurs (setSymbole et setNomSynthèse) que je ne saurais voir, de manière à pouvoir utiliser un code qui serait d'avantage proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){ std::shared_ptr<terminal>E1=std::make_shared<terminal>(SYMBOLE::dolar); pile.push_back(E1); std::shared_ptr<nonTerminal>E2=std::make_shared<nonTerminal>(SYMBOLE::C); E2->setSymbole(); pile.push_back(E2); std::shared_ptr<synthese>E3=std::make_shared<synthese>(typeSynthese::synthC); E3->ajoute(""); E3->ajoute(""); pile.push_back(E3); }
au passage, as tu remarqué que tu transmet une donnée de type typeSynthese à une fonction nommée setNomSynthese:question:

Il y a quelque chose de "pas normal", parce que, dans la tête de tout le monde, un nom n'est pas d'avantage un type que l'inverse. Or, une synthèse pourrait très bien être d'un type particulier typeSynthese::synthC et avoir un nom qui lui est propre (ex: "mai-2020"), si tu estimes qu'il est possible, à un moment donné de l'exécution, d'avoir deux synthèses différentes. Le nom deviendrait alors l'élément qui te permettra de les différencier (parce que l'autre, également de type typeSynthese::synthC porterait le nom de"avril-2020" par exemple).

Et cela m'amène à une une autre remarque: il faut être cohérent dans le choix noms (de type de données, de données et de fonctions):

au niveau de la "casse" (la différence minuscules / majuscules) en premier: tous les types doivent avoir la même casse. Pourquoi SYMBOL est-il en majuscule alors que typeSynthese est en camelCase :question:
Au niveau du nom utilisé ensuite: le nom (devrait) permet(tre) au lecteur de se faire une idée précise de l'usage auquel est destiné un élément. Le meilleur moyen d'y arriver, c'est de choisir un nom qui soit effectivement en rapport avec cet usage.

Citation:

Envoyé par Argagon (2006)

Blissingr signifie le feu. C'est le feu.
Le nom, c'est la chose
Connaît le nom, et tu maîtrise la chose

Enfin, je doute très fort que cette logique doive apparaître au niveau du constructeur de ta classe, même si je comprend parfaitement que l'idée soit d'avoir systématiquement ces trois éléments en début de pile. La raison de mon doute est cependant toute simple:

Le principe même d'une pile est de récupérer l'élément qui se trouve "au sommet" de la pile, de le traiter, puis de le retirer; et ce, "tant qu'il y a un élément" dans la pile.

Les trois éléments (symbole dollar, symbole c, et syntheseC) vont donc ** forcément ** finir par être supprimé de la pile. Et la logique de travail de ta syntaxe devrait s'arrêter.

Par contre, ce n'est pas parce que tous les éléments de syntaxe ont été traités (et retirés de la pile) que l'instance de ta classe syntaxe va ** forcément ** être détruite. Après tout, tu pourrais très bien décider de réutiliser cette instance pour traiter "un nouveau jeu de données syntaxiques", ce qui sera sans doute "plus efficace" que de devoir commencer par détruire l'instance existante pour ... le plaisir d'en créer une nouvelle.

Et tu voudras très certainement que ces trois éléments se retrouvent de nouveau au tout début de ta pile. Personnellement, j'aurais tendance à dire que cette logique devrait faire partie d'une fonction de ta classe (privée pour que l'utilisateur n'ait pas la possibilité d'y faire appel "n'importe quand") qui pourrait être appelée à chaque fois que l'on décide de commencer à traiter un nouveau "jeu syntaxique".

Enfin, bref... Pour répondre à ta question: pourquoi

Code:

auto const & X=pile[pile.size() -1],

:

auto parce que c'est plus facile que commencer à écrire le type précis de l'élément qui se trouve en pile (qui est de type std::shared_ptr<XXX>, même si je conseillerais de passer à un std::unique_ptr)
const parce que l'on ne veut surtout pas avoir la possibilité de modifier l'élément obtenu
& pour indiquer que l'on veut récupérer une référence sur l'élément qui se trouve dans la pile, ce qui permet d'éviter la copie (qui serait interdite avec un std::unique_ptr et qui, dans ton cas, nécessiterait de mettre la logique de comptage de référence en branle)

comme je disait

Citation:

Vu que X recopie le sommet de la pile, sans dépiler, ne suis-je pas obligé d'utiliser shared_ptr?

en modifiant pour opter pour unique_ptr, j'ai bien la méthode ajoute(std::string). Pourquoi ça ne compile plus?

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 #include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::unique_ptr<enregistrement>E;
  E=std::make_unique<terminal>(SYMBOLE::dolar);
  //E->setSymbole(SYMBOLE::dolar);
  pile.push_back(std::move(E));
  E=std::make_unique<nonTerminal>(SYMBOLE::C);
  //E->setSymbole(SYMBOLE::C);
  pile.push_back(std::move(E));
  E=std::make_unique<synthese>(typeSynthese::synthC);
  //E->setNomSynthese(typeSynthese::synthC);
  E->ajoute("");
  E->ajoute("");
  E->setActionSemantique(1);
  pile.push_back(std::move(E));
}
 
void syntaxique::anaSynt(){
  uniLex lu;
  lu=pe.anaLex();
  a=lu.getLex();/*"a" est indiqué ainsi dans le dragonbook, 
		  c'est l'unité lexicale lu par l'analyseur lexical*/
 
  pile.back();
  while( ! X->vaut(ULEX::dolar)){// X, aussi comme a. Sommet de la pile
    if(X->vaut(a)){
      pile.pop_back();
      lu=pe.anaLex();
      a=lu.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<lu.getLexeme()<<" inattendu"<<std::endl;
	lu=pe.anaLex();
	a=lu.getLex();
      }
    switch(X->quelType()){
    case type::TnonTerminal:
      if(X->getSymbole()==SYMBOLE::C)
	if(a==ULEX::a){
	  pile.pop_back();
	  std::unique_ptr<synthese>temp=
	    std::make_unique<synthese>(typeSynthese::synthA1);
	  temp.ajoute("");
	  temp.ajoute("");
	  temp=std
	}
    }
  }
}

Code:

1
2
3
4
enregistrement.hpp
class synthese:public enregistrement{
void ajoute(std::string const &valAttr)override;
};

Code:

1
2
3
4
5
6
7
8
9
10
11
$ g++ -c syntaxique.cpp
syntaxique.cpp: In member function ‘void syntaxique::anaSynt()’:
syntaxique.cpp:52:9: error: ‘class std::unique_ptr<synthese, std::default_delete<synthese> >’ has no member named ‘ajoute’
   52 |    temp.ajoute("");
      |         ^~~~~~
syntaxique.cpp:53:9: error: ‘class std::unique_ptr<synthese, std::default_delete<synthese> >’ has no member named ‘ajoute’
   53 |    temp.ajoute("");
      |         ^~~~~~
syntaxique.cpp:55:2: error: expected primary-expression before ‘}’ token
   55 |  }
      |  ^

quelqu'un a une idée?

26/03/2020, 07h35
emmesse

évidement, il fallait faire:

Code:

temp->ajoute("")

j'ai ce syntaxique.cpp qui compile correctement, mais si je fait:

Code:

X=std::move(pile.back)

le somment de pile sera-t-il encore "intact"?

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::unique_ptr<enregistrement>E;
  E=std::make_unique<terminal>(SYMBOLE::dolar);
  pile.push_back(std::move(E));
  E=std::make_unique<nonTerminal>(SYMBOLE::C);
  pile.push_back(std::move(E));
  E=std::make_unique<synthese>(typeSynthese::synthC);
  E->ajoute("");
  E->ajoute("");
  E->setActionSemantique(1);
  pile.push_back(std::move(E));
}
 
void syntaxique::anaSynt(){
  uniLex lu;
  std::unique_ptr<enregistrement>temp;
  lu=pe.anaLex();
  a=lu.getLex();/*"a" est indiqué ainsi dans le dragonbook, 
		  c'est l'unité lexicale lu par l'analyseur lexical*/
 
  X=pile.back();
  while( ! X->vaut(ULEX::dolar)){// X, aussi comme a. Sommet de la pile
    if(X->vaut(a)){
      pile.pop_back();
      lu=pe.anaLex();
      a=lu.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<lu.getLexeme()<<" inattendu"<<std::endl;
	lu=pe.anaLex();
	a=lu.getLex();
      }
    switch(X->quelType()){
    case type::TnonTerminal:
      if(X->getSymbole()==SYMBOLE::C)
	if(a==ULEX::a||a==ULEX::b){
	  pile.pop_back();
	  temp=std::make_unique<synthese>(typeSynthese::synthA1);
	  temp->ajoute("");
	  temp->ajoute("");
	  pile.push_back(std::move(temp));
	  temp=std::make_unique<nonTerminal>(SYMBOLE::A);
	  pile.push_back(std::move(temp));
	}
	else if(a==ULEX::sep){
	  std::cerr<<"le fichier commence par une virgule"<<std::endl;
	  lu=pe.anaLex();
	  a=lu.getLex();
	}
	else if(a==ULEX::dolar)
	  pile.pop_back();
    }
    //inachevé
    X=std::move(pile.back());
  }
}

Bonjour,

Si tu "move" un unique_ptr, tu le transfères. Donc après avoir effectué X = std::move( pile.back() );, X est celui possède l'objet et le sommet de la pile aura un unique_ptr vidé de son élément. Il faut alors ne pas oublier d'enlever cet unique_ptr du sommet.
Code:

1 2 3 4 5 X = std::move( pile.back() ); if ( pile.back() ) // essayons de voir s'il reste quelque chose! std::cout << "ce message n'est pas affiché!"; else pile.pop_back(); // ne pas conserver un pointeur vide dans la pile

la pile doit rester intact, j'utiliserais dons shared_ptr

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <memory>
#include <iostream>
#include "syntaxique.hpp"
#include "enregistrements.hpp"
 
syntaxique::syntaxique(std::string const &nomFichier):pe(nomFichier){
  std::shared_ptr<enregistrement>E;
  E=std::make_shared<terminal>(SYMBOLE::dolar);
  pile.push_back(E);
  E=std::make_shared<nonTerminal>(SYMBOLE::C);
  pile.push_back(E);
  E=std::make_shared<synthese>(typeSynthese::synthC);
  E->ajoute("");
  E->ajoute("");
  E->setActionSemantique(1);
  pile.push_back(E);
}
 
void syntaxique::anaSynt(){
  uniLex lu;
  std::shared_ptr<enregistrement>temp;
  lu=pe.anaLex();
  a=lu.getLex();/*"a" est indiqué ainsi dans le dragonbook, 
		  c'est l'unité lexicale lu par l'analyseur lexical*/
 
  X=pile.back();
  while( ! X->vaut(ULEX::dolar)){// X, aussi comme a. Sommet de la pile
    if(X->vaut(a)){
      pile.pop_back();
      lu=pe.anaLex();
      a=lu.getLex();
    }
    else if(X->estTerminal())
      if(a==ULEX::dolar){
	std::cerr<<"Fichier source inachevé"<<std::endl;
	exit(1);
      }
      else{
	std::cerr<<lu.getLexeme()<<" inattendu"<<std::endl;
	lu=pe.anaLex();
	a=lu.getLex();
      }
    switch(X->quelType()){
    case type::TnonTerminal:
      if(X->getSymbole()==SYMBOLE::C)
	if(a==ULEX::a||a==ULEX::b){
	  pile.pop_back();
	  temp=std::make_shared<synthese>(typeSynthese::synthA1);
	  temp->ajoute("");
	  temp->ajoute("");
	  pile.push_back(temp);
	  temp=std::make_shared<nonTerminal>(SYMBOLE::A);
	  pile.push_back(temp);
	}
	else if(a==ULEX::sep){
	  std::cerr<<"le fichier commence par une virgule"<<std::endl;
	  lu=pe.anaLex();
	  a=lu.getLex();
	}
	else if(a==ULEX::dolar)
	  pile.pop_back();
    }
    //inachvé
    X=pile.back();
  }
}

le sujet du message est "enregistrement ne compile pas". Maintenant que tout compile bien, le problème est résolu. Merci chalereux pour votre aide,

26/03/2020, 12h30
Bousk

Mauvaise réponse.
Tu n'as aucunement besoin d'un shared_ptr ici.
Un unique_ptr est la solution. Et pour utiliser sa valeur tu n'as pas besoin de le déplacer... tu peux utiliser get et récupérer un pointeur.
26/03/2020, 13h55
Invité

En prêtant une attention particulière à la durée de vie de l'objet. Un pile.pop_back() va détruire l'unique_ptr et l'objet avec lui, et on se retrouvera avec des dangling référence / pointeur.
26/03/2020, 14h41
emmesse

@winjerome. y aura-t-il aussi des dangling référence / pointeur avec shared_ptr?
si oui, comment détruire l'objet?
26/03/2020, 17h40
Invité

Oui et non.
La référence sur le std::shared_ptr contenu dans la pile sera tout autant dangling.
Par contre, si tu conserves comme tu le fais une copie X = pile.back();, alors X partagera la responsabilité avec l'élément dans la pile et continuera (seul) passé le pile.pop_back();.
27/03/2020, 16h32
emmesse

merci pour vos éclaircissements