Manipulation d'un vecteur 3D

Version imprimable

2 pièce(s) jointe(s)

Bonjour,

Afin de réaliser mon projet, j'essaie de stocker les données d'un fichier texte dans un vecteur 3d mais je n'y arrive pas tout à fait.

Voici le format de mon fichier texte.

Pièce jointe 204670

Voici ma fonction pour lire le fichier texte et stocker les données dans la mémoire.
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 void lectureFichier(ifstream& fichier, vector< vector< vector<string> > >& gram){ // on enregistre premier caractere du fichier texte dans une variable temporaire string temp; fichier >> temp; // tant que ce n'est pas la fin du fichier while(!fichier.eof()){ // on crée un nouveau vecteur 2d vector< vector<string> > ligne; // tant que ce n'est pas la fin de la ligne while(temp != "-1"){ vector<string> terme; while(temp != "|" && temp != "=" && temp != "-1"){ terme.push_back(temp); fichier >> temp; } // on stocke le caractere dans le vecteur appelé ligne ligne.push_back(terme); // on stocke prochain caractere dans la variable fichier >> temp; } // on ajoute le vecteur ligne dans le vecteur gram gram.push_back(ligne); // on stocke prochain caractere dans la variable fichier >> temp; } }
Enfin, je voudrais que les donées soient stockées ainsi dans mon vecteur.

Pièce jointe 204672

Cependant, quand j'exécute mon code, tous les données sont stockées dans un seule indice "i", c'est-à-dire que le T qui est censé être dans gram[1][0][0], se retrouve dans gram[0][3][0].

Ayant vérifié à plusieurs reprises mon code, je ne vois pas d'où vient l'erreur.

Merci d'avance pour vos réponses. :D

Je te conseil de faire en deux fois pour plus de clarté. Voilà ce que ça donne en java :

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
package test;
 
import java.io.File;
import java.io.IOException;
 
import com.google.common.base.Charsets;
import com.google.common.io.Files;
 
import java.util.ArrayList;
import java.util.Arrays;
 
public class Test {
    private static String filePath = "C:/Users/LD/Desktop/001.txt";
 
    public static void main(String[] args) {
        try {
            String fileContent = Files.toString(new File(filePath), Charsets.ISO_8859_1);
            String[] lines = fileContent.split("-1");
 
            ArrayList<ArrayList<ArrayList<String>>> gram = new ArrayList<ArrayList<ArrayList<String>>>();
            for (String line : lines) {
                gram.add(readLine(line.trim()));
            }
 
            showArray(gram);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private static ArrayList<ArrayList<String>> readLine(String line) {
        ArrayList<ArrayList<String>> array_line = new ArrayList<ArrayList<String>>();
        String[] first_split = line.split("=");
 
        // j = 0
        ArrayList<String> first_array = new ArrayList<String>();
        first_array.add(first_split[0].trim());
        array_line.add(first_array);
 
        // j > 0
        String[] second_split = first_split[1].split("\\|");
        for (String string : second_split) {
            ArrayList<String> new_array = new ArrayList<String>(Arrays.asList(string.trim().split(" ")));
            array_line.add(new_array);
        }
 
        return array_line;
    }
 
    private static void showArray(ArrayList<ArrayList<ArrayList<String>>> gram) {
        for (int i = 0; i < gram.size(); ++i) {
            for (int j = 0; j < gram.get(i).size(); ++j) {
                System.out.print("i = "+i+", j = "+j+",    ");
                for (int k = 0; k < gram.get(i).get(j).size(); ++k) {
                    System.out.print("k["+k+"] = "+gram.get(i).get(j).get(k)+", ");
                }
                System.out.print("\n");
            }
            System.out.print("\n");
        }
    }
}

Salut,

Citation:

Envoyé par CliffeCSTL

Je te conseil de faire en deux fois pour plus de clarté. Voilà ce que ça donne en java :

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
package test;
 
import java.io.File;
import java.io.IOException;
 
import com.google.common.base.Charsets;
import com.google.common.io.Files;
 
import java.util.ArrayList;
import java.util.Arrays;
 
public class Test {
    private static String filePath = "C:/Users/LD/Desktop/001.txt";
 
    public static void main(String[] args) {
        try {
            String fileContent = Files.toString(new File(filePath), Charsets.ISO_8859_1);
            String[] lines = fileContent.split("-1");
 
            ArrayList<ArrayList<ArrayList<String>>> gram = new ArrayList<ArrayList<ArrayList<String>>>();
            for (String line : lines) {
                gram.add(readLine(line.trim()));
            }
 
            showArray(gram);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private static ArrayList<ArrayList<String>> readLine(String line) {
        ArrayList<ArrayList<String>> array_line = new ArrayList<ArrayList<String>>();
        String[] first_split = line.split("=");
 
        // j = 0
        ArrayList<String> first_array = new ArrayList<String>();
        first_array.add(first_split[0].trim());
        array_line.add(first_array);
 
        // j > 0
        String[] second_split = first_split[1].split("\\|");
        for (String string : second_split) {
            ArrayList<String> new_array = new ArrayList<String>(Arrays.asList(string.trim().split(" ")));
            array_line.add(new_array);
        }
 
        return array_line;
    }
 
    private static void showArray(ArrayList<ArrayList<ArrayList<String>>> gram) {
        for (int i = 0; i < gram.size(); ++i) {
            for (int j = 0; j < gram.get(i).size(); ++j) {
                System.out.print("i = "+i+", j = "+j+",    ");
                for (int k = 0; k < gram.get(i).get(j).size(); ++k) {
                    System.out.print("k["+k+"] = "+gram.get(i).get(j).get(k)+", ");
                }
                System.out.print("\n");
            }
            System.out.print("\n");
        }
    }
}

Primo : heu... as tu remarqué que nous sommes dans la section ... C++ :question: question: un code java, ca la fout mal si l'idée est de le faire en C++ ;)

secundo : il est d'usage d'éviter de donner des solutions "toutes faites" et d'essayer à la place de donner des indications qui permettraient au PO de résoudre le problème "par lui-même"
N'oublie pas ce que dit le dicton

Citation:

donnes un poisson à quelqu'un, il mangera un jour;
apprend lui à pêcher, il mangera toute sa vie

;)

23/03/2016, 09h12
CliffeCSTL

Bah justement, j'ai pas donné une solution toute faite en C++ :D

J'ai proposé en Java par soucis de rapidité ...

Ton projet est assez amusant, car tu dois faire l'analyse syntaxique d'une grammaire, elle-même utilisée plus tard, j'imagine, pour faire de l'analyse syntaxique. Enfin on s'amuse comme on peut. La conclusion de cette remarque, c'est qu'il te faut une grammaire pour faire l'analyse syntaxique de cette grammaire ;)

A priori qqc comme (je manque un peu de pratique):
R = D "-1" | D "-1\n" D
D = O | O '|' O
O = V op V | V
V = char | {}

Le mieux est de séparer l'analyse du flux de l'analyse de son contenu: c'est-à-dire qu'il faut transformer un flux de caractères en flux de tokens (par exemple "=", "F", "-1") qui ont une signification au sein de la grammaire.

Ensuite tu peux modeler ton programme en fonctions qui correspondent à chacune de ces règles:
Code:

1 2 3 4 vector<vector<vector<string>>> rules(Tokens toks); vector<vector<string>> definitions(Tokens toks); vector<string> operatrions (Tokens toks); string var_ops(Tokens toks);;
la fonction la plus haute appelle celle un cran en dessous, etc.
par exemple (grosso modo):
Code:

1 2 3 4 5 6 7 8 9 10 vector<vector<string>> definitions(Tokens toks) { if toks.empty() return {}; vector<vector<string>> result; result.push_back(operations(toks)); // operations consomme le flux de tokens selon sa propre définition (variable operateur variable ou variable seule) while (!toks.empty() && toks.get_next() == "|") { toks.pop(); // on consomme le séparateur "|"; result.push_back(operations(toks)); } return result; }