Discussion :

[emmesse]

Bonjour,

comment fait-on pour accéder, par exemple, au troisième pair d'un unordered_multimap avec quelqque chose qui ressemblerai à un indice?

Code :

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

std::unordered_multimap< std::string , std::vector<std::string> >G;

une idée?

[Bktero]

Bonjour

Comment accéder au n-ième élément d'une collection dont les éléments ne sont pas numérotés ?

Hum....

C'est quoi le 3e élément si la map est "unordered" ?

[emmesse]

peut-être qu'il me faut autre chose qu'un unordered multimap.
j'ai ces productions:

Code :

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

1
2
3
4
5
S -> A a
S -> b
A -> A c
A -> S d
A-> epsilon

je voudrais accéder d'une manière simple à l'une de ces productions, et/ou en ajouter une entre deux autres, ou bien encore en modifier une
j'utilisais un vector, mais on m'a dit que je me compliquai le travail avec.
une idée?

[dalfab]

Si l'ordre des productions doit être conservé, la unordered_multimap<> n'est pas utilisable. Comme l'a indiqué @Bktero les éléments ne sont pas à une position donnée. Dans une unordered_multimap<> :

Code :

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

1
2
3
4
5
S -> A a
S -> b
A -> A c
A -> S d
A-> epsilon

est la même chose que:

Code :

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

1
2
3
4
5
A-> epsilon
A -> A c
A -> S d
S -> b
S -> A a

.Si tu ajoutes un élément (par exemple avec insert()) il se mettra quelque part dans la unordered_multimap<>. Précise mieux ton besoin. Il semble qu'il te faut utiliser la collection qui conserve l'ordre donc c'est plutôt std::vector<>

[emmesse]

voici comment je m'y suis pris:

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
#ifndef GRAMMAIRE_HPP
#define GRAMMAIRE_HPP
 
class grammaire{
public:
  std::vector<std::vector<std::string>>presencerecurs();
  int comptertete(std::string tete);
  int termine(std::string s);
  void parseur();
private:
  std::vector<std::vector<std::string>>grammaire_s;
  std::string axiome;
  std::vector<std::string>terminaux;
  std::vector<std::string>nonterminaux;
  std::vector<std::vector<std::string>>listesnonrecurs;
};
#endif

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
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
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "grammaire.hpp"
 
int main(){
  std::vector<std::vector<std::string>>listerecurs;
  grammaire G;
  G.parseur();
  listerecurs =G.presencerecurs();
  for(auto p:listerecurs){
    for(auto s:p)
      std::cout<<s<<' ';
    std::cout<<std::endl;
  }
  return 0;
}
 
void grammaire::parseur(){
  terminaux={"a","b","c","d","epsilon"};
  nonterminaux={"S","A"};
  grammaire_s={
    {"S","A","a"},     // S -> A a
    {"S","b"},           // S -> b
    {"A","A","c"},     // A -> A c
    {"A","S","d"},     // A -> S d
    {"A","epsilon"}   // A -> epsilon
  };
  axiome="S";
}
 
 
std::vector<std::vector<std::string>>
grammaire::presencerecurs(){
  std::vector<std::vector<std::string>>temporaire,archive;
  std::vector<std::string> unelistenonrecurs;
  int n1,n2;
 
  n1=comptertete(axiome);
  for(int i=0;i<n1;i++){
    unelistenonrecurs.push_back(axiome);
    listesnonrecurs.push_back(unelistenonrecurs);
    unelistenonrecurs.clear();
  }
  for(auto p:grammaire_s){
    temporaire.clear();
    n2=termine(p[0]);//listenonrecursterminé par p[0]
    if(n2!=-1){
      unelistenonrecurs=listesnonrecurs[n2];
      if(std::find(nonterminaux.begin(),nonterminaux.end(),p[1])!=nonterminaux.end()){
	if(std::find(unelistenonrecurs.begin(),unelistenonrecurs.end(),p[1])!=unelistenonrecurs.end()){
	  while(unelistenonrecurs[0]!=p[1])
	    unelistenonrecurs.erase(unelistenonrecurs.begin());
	  archive.push_back(unelistenonrecurs);//recurs gauche détectée
	  listesnonrecurs.erase(listesnonrecurs.begin()+n2);
	  continue;
	}
	else{
	  unelistenonrecurs.push_back(p[1]);
	  n1=comptertete(p[1]);
	  for(int i=0;i<n1;i++)
	    temporaire.push_back(unelistenonrecurs);
	  listesnonrecurs.erase(listesnonrecurs.begin()+n2);
	  listesnonrecurs.insert(listesnonrecurs.end(),temporaire.begin(),temporaire.end());
	}
      }
      else
	listesnonrecurs.erase(listesnonrecurs.begin()+n2);
    }
  }
  return archive;
}
 
int grammaire::termine(std::string fin){
  //retourne l'indice de liste tel que 'fin' soit son dernier symbole
  for(size_t i=0;i<listesnonrecurs.size();i++)
    if(listesnonrecurs[i].back()==fin)
      return i;
  return -1;
}
 
int grammaire::comptertete(std::string s){
  int c=0;
  for(auto &p:grammaire_s)
    if(s==p[0])
      c++;
  return c;
}

[deedolith]

Salut,

Ce que tu décrit me fait fortement penser aux collections VB6.
C'est un conteneur qui associe une clef à une valeur.
Les items sont insérés dans l'ordre.
On peut accéder aux items par clef ou par indice.

Tu peux te faire une classe qui ressemble à ceci:

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
37
38
39
40
41
42
43
44
45
46
47
48
#include <string>
#include <vector>
#include <utility>
 
class Collection
{
private:
	std::vector<std::pair<std::string, std::string>> mData;
public:
	std::string get(size_t) const;
	std::string get(std::string const&);
	void insert(std::pair<std::string, std::string> const&);
        void remove(size_t);
	void remove(std::string const&);
        size_t size() const;
};
 
#include "Collection.h"
 
std::string Collection::get(size_t index) const
{
	// retourne le 2e element (la valeur) de la paire à l'indice index
}
 
std::string Collection::get(std::string const& key)
{
	// recherche dans mData quel premier element (la clef) des pairs stockées correspond à key
}
 
void Collection::insert(std::pair<std::string, std::string> const&)
{
	// une insertion bête et mechante
}
 
void Collection::remove(size_t index)
{
       // voir commentaire get(size_t index)
}
 
void Collection::remove(std::string const& key)
{
       // voir commentaire get(std::string const& key)
}
 
size_t Collection::size() const
{
	return mData.size();
}

A toi de voir si tu veux des intérateur.