Discussion :

[scheme]

Bonjour à tous, je dois recoder un programme de C++ vers Java. Ce n'est pas si simple qu'il y paraît car même si de nombreux concepts sont identiques, l'implémentation ne l'est pas.

Mon problème du genre si situe avec les iterators. En C++ ça donne ça:

Code :

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

1
2
3
4
// l'implémentation C++ est tres certainement incorrecte
// c'est juste pour comprendre le principe et ce que je veux faire
vector<vector<int> >::iterator it = vv_val_.begin();
if( (it-1)->at(0)+(it+1)->at(0) < 2*it->at(0) ) { ... }

C'est super flexible, on peut jouer avec les opérateurs sans problèmes.

En java, je ne vois pas imiter ce it-1

Si j'implémente un ListIterator it, je peux seulement faire it.previous() , ce qui n'est pas la même chose car l'index est réellement modifié, alors qu'en C++ non.

Je n'arrive pas à trouver la solution de ce probleme, avez-vous une idée ?
Merci d'avance

[adiGuba]

Salut,


Attention le C++ et Java ont des optiques très différentes. Il est très casse-gueule de vouloir "traduire" un code de l'un vers l'autre (et inversement).

Que veux-tu faire exactement avec ceci ???

a++

[scheme]

En gros, l'algo de C++ utilise les iterators avec les opérators.
Donc on peut faire (it-1)->method() sans que la position d'it soit modifiée.

J'aimerais imiter ceci en Java, et j'ai l'impression que le langage ne le permet pas.

J'ai codé une méthode pour illustrer ce que je voudrais faire, mais c'est lourd et s'il y a un moyen de faire autrement, je suis preneur

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
public enum Direction { PREVIOUS, NEXT }
 
public ListIterator manageIterator(ListIterator target, Direction direction, int stepNumber) {
 
        ListIterator temp = target;
        switch (direction) {
            case PREVIOUS:
                for (int i = 0; i < stepNumber; i++) {
                    if (temp.hasPrevious()) {
                        temp.previous();
                    }
                }
                break;
            case NEXT:
                for (int i = 0; i < stepNumber; i++) {
                    if (temp.hasNext()) {
                        temp.next();
                    }
                }
                break;
        }
        return temp;
    }

Si j'utilise cette méthode pour ce que je veux faire, ça donne:

Code :

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

1
2
ListIterator<ArrayList<Double>> it = monObjet.listIterator(1);
if( manageIterator(it, Direction.PREVIOUS, 1).get(0) + manageIterator(it, Direction.NEXT, 1).get(0) ....... // on continue

Comme vous le voyez, c'est extremement lourd ! Donc s'il y a une autre solution, je prend ^^

[adiGuba]

Quand je demande ce que tu veux faire, je ne demande pas comment tu veux convertir ton algo C++ (ce n'est pas une bonne idée).

Je veux simplement savoir quel est l'objectif final de tout cela. Que dois-tu faire ?

a++

[scheme]

J'ai des collections imbriquées qui contiennent des données physiques et je dois coder une fonction de compression.

J'ai une version en C++ (qui a été codée par quelqu'un d'autre) qui convient bien, mais elle joue beaucoup sur les iterators et j'ai du mal à imiter ça en Java.

J'avoue que je ne vois pas comment faire autrement, je peux toujours poster la fonction si ça peut être utile.

[scheme]

pour l'instant je passe par des accesseurs plutôt que des iterators, c'est moins lisible mais ça fonctionne

[adiGuba]

Comme je l'ai dit le copier/coller d'un algorithme C/C++ n'est généralement pas très bon.


Reprend tout à zéro comme si tu n'avait pas de code C++.

Quel est ta structure de données ? Que contient-elle ?
Que dois-tu en faire ?

a++

[tchize_]

L'utilisation d'un intérateur dans ce cas n'a aucun intérêt, puisqu'on va regarder aussi des données partout ailleurs. Utilisez directement une List<List<Int>> et un index:

Code :

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

if( (l.get(it-1).get(0)+l.get(it+1).get(0) < 2*l.get(it).get(0) ){....}

Ceci, en supposant que vous tenez à garder vos structure.