Discussion :

[vbaddict44]

Bonjour,

j'aurais besoin de trier un vector personnalisé je vous explique:

le vector est de type <Structure*> et Structure est une classe abstraite avec différentes classes filles qui sont :

-LongitudinalBulkhead
-InnerDeck
-WeatherDeck ...

voila ce que j'ai pour l'instant pour trier le tableau en fonction d'une variable qui s'appel position contenu dans chaques classes filles:

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
 
    Structure* a;
    Structure* b;
 
    if(struc->retour_type() == "WeatherDeck" || struc->retour_type() == "InnerDeck")
    {
        for(std::vector<Structure*>::iterator p = collec_elem_attaches.begin(); p!=collec_elem_attaches.end();++p)
        //for(size_t i = 0 ; i< collec_elem_attaches.size() ; ++i)
        {
            for(std::vector<Structure*>::iterator q = collec_elem_attaches.begin(); q!=collec_elem_attaches.end()-1;++q)
            {
 
               if((*q)->retour_position() > (*++q)->retour_position())
               {
                   a=(*q);
                   b=(*++q);
                   collec_elem_attaches.erase(q++);
                   collec_elem_attaches.insert(q,b);
 
               }
            }
        }
    }
    else if(struc->retour_type()== "LongitudinalBulkhead")
    {
       for(std::vector<Structure*>::iterator p = collec_elem_attaches.begin(); p!=collec_elem_attaches.end();++p)
        {
           for(std::vector<Structure*>::iterator q = collec_elem_attaches.begin(); q!=collec_elem_attaches.end()-1;++q)
            {
               if((*q)->retour_position() > (*++q)->retour_position())
               {
                   a=(*q);
                   b=(*++q);
                   collec_elem_attaches.erase(q++);
                   collec_elem_attaches.insert(q,b);
 
 
               }
            }
        }
    }

[Bousk]

Bonjour,

pour trier un std::vector, il suffit d'utiliser std::sort.
Avec le foncteur adéquat à créer ou l'utilisation des opérateurs membres de comparaison, ton code sera très simplifié.

[vbaddict44]

Oui j'ai vu cette solution mais je ne sait pas comment l'appliquer avec mon code aurais tu un exemple ?

Code :

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

1
2
 
 std::sort(collec_elem_attaches.begin(),collec_elem_attaches.end());

me dit que sort ne fait pas parti de std.

[Bousk]

La comparaison pour savoir si un item précède ou non l'autre c'est ça je suppose

Code :

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

1
2
3
4
5
6
7
8
if((*q)->retour_position() > (*++q)->retour_position())
               {
                   a=(*q);
                   b=(*++q);
                   collec_elem_attaches.erase(q++);
                   collec_elem_attaches.insert(q,b);
 
               }

Le plus simple c'est l'opérateur<, utilisé par défaut si on n'utilise pas de foncteur.
N'ayant aucune connaissance de ton code, je dirais ça à tout hasard

Code :

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

1
2
3
4
5
6
7
8
class Structure
{
public:
 bool operator<(const Structure& st) const
{
 return retour_position() < st.retour_position();
}
};

me dit que sort ne fait pas parti de std.

#include <algorithm> ?


btw, pourquoi faire un if et else if pour écrire 2 algorithmes strictement identiques ?

[vbaddict44]

oui je viens de remarquer ca aussi enfet je suis en stage et je reprend le code d'un élève qui à effectué son stage l'année dernier donc je ne peut pas te dire pk il a fait ça
je test ta solution et je reviens vers toi merci

[cob59]

Puisque tes vecteurs contiennent des pointeurs et pas les éléments eux-même, je ne crois pas que surcharger Structure::operator< sera suffisant.
Je verrais plutôt un objet-fonction :

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
 
// Solution C++ classique
struct Comparator {
  bool operator()(const Structure* a, const Structure* b) {
    return ( a->retour_position() < b->retour_position() );
  }
} comparator;
 
// Solution C++11
auto comparator = [] (const Structure* a, const Structure* b) -> bool {
  return ( a->retour_position() < b->retour_position() );
};
 
// Tri
std::sort(collec.begin(), collec.end(), comparator);

[Bousk]

Puisque tes vecteurs contiennent des pointeurs et pas les éléments eux-même, je ne crois pas que surcharger Structure::operator< sera suffisant.
Je verrais plutôt fait un objet-fonction

Ce qui permet de retomber sur tes pates, dans la mesures où l'opérateur utilise juste la méthode retour_position() qui, j'espère est bien faîte, et est probablement virtual (sinon aucune solution de fonctionne de toutes façons) et donc indépendant de la vraie Structure.

[vbaddict44]

cela ne fonctionne pas le tableau est trié comme cela :


ordre avant le tri : -0.6
ordre avant le tri : 0
ordre avant le tri : 0.6
ordre avant le tri : -0.44
ordre avant le tri : 0.44

ordre après le tri : -0.44
ordre après le tri : 0.44
ordre après le tri : -0.6
ordre après le tri : 0
ordre après le tri : 0.6

[Bousk]

Etant donné que le principe est le bon, vérifie plutôt les retours de retour_fonction().
Mais ça sort désormais de notre périmètre (sauf boule de cristal).

Bienvenue dans la phase de debug.

[vbaddict44]

bon ca sera pour demain alors merci beaucoup pour ton aide

[vbaddict44]

Ce code fonctionne j'ai finalement fait sans le sort :

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
 
 Structure* a;
    Structure* b;
 
       for(size_t i = 0 ; i< collec_elem_attaches.size() ; ++i)
        {
                for(size_t j = 0 ; j< collec_elem_attaches.size() ; ++j)
                {
                    if(collec_elem_attaches.size() > j+1 )
                    {
 
                       if(collec_elem_attaches[j]->retour_position() > collec_elem_attaches[j+1]->retour_position())
                       {
                           a=collec_elem_attaches[j];
                           b=collec_elem_attaches[j+1];
                           collec_elem_attaches.insert(collec_elem_attaches.begin() + j ,b);
                           collec_elem_attaches.erase(collec_elem_attaches.begin() + (j+2));
 
                       }
                    }
                  }
 
        }