Bonjour !  :)

J'aimerai savoir si il est possible de trier plusieurs vector (qui auraient les mêmes membres) et de récupérer un tableau ou un autre vector qui contiendrai le "tri" de mes vector ?

Par exemple, imaginons que j'ai trois classes :

PointA(), PointB() et PointC()

Chaque classe contient 2 entiers : X et Y et une fonction traitement();

Imaginons maintenant que j'ai 2 instances de chaque classe dans des vector ... donc 3 vector de 2 instances.

std::vector<PointA> vec_A : contient 2 instances de PointA()

std::vector<PointB> vec_B : contient 2 instances de PointB()

std::vector<PointC> vec_C : contient 2 instances de PointC()

Comment faire pour récupérer un tableau ou un nouveau vector contenant les adresses des instances de mes 3 classes triées dans l'ordre de leur propriété Y ? Est-ce possible ??

Par exemple, si j'ai :

vec_A[0].y = 2

vec_A[1].y = 6

vec_B[0].y = 1

vec_B[1].y = 5

vec_C[0].y = 9

vec_C[1].y = 7

Je voudrais récupérer un tableau ou un vector qui contiendrai non pas les valeurs Y mais un pointeur vers chaque classe concernée, trié par Y croissant :

vec_resultat[0] = &vec_B[0]

vec_resultat[1] = &vec_A[0]

vec_resultat[2] = &vec_B[1]

vec_resultat[3] = &vec_A[1]

vec_resultat[4] = &vec_C[1]

vec_resultat[5] = &vec_C[0]

pour pouvoir par la suite utiliser :

for(int i = 0; i < 6; i++) vec_resultat[i]->traitement() 

par exemple !

En faite ça me parait impossible car que vec_resultat soit un tableau ou un vector il faut déclarer son type ... hors là il est sencé contenir des adresses de plusieurs types différents ...

Mais sinon ... c'est possible ???

Merciiii d'avoir lu mon problème assez compliqué ... lol  ^^

salut,



si tu dérive tes 3 classes a partir d'une classe unique il devrait etre possible de faire un cast.
je suis pas sur, n'etant pas un expert en matière de c++

@++

Je viens d'essayer en créant 3 classes :

npc()
et
bomb()

qui dérivent de la classe element()

Voici les sources :

---

ELEMENT.H

#ifndef ELEMENTS_H
#define ELEMENTS_H

#include <iostream>


class elements
{
    public:
        elements();
        virtual ~elements();
        int m_y;
    protected:
    private:
};



#endif // ELEMENTS_H

---

ELEMENTS.CPP

#include "elements.h"


elements::elements()
{
    m_y = 0;
}

elements::~elements()
{

}

---

NPC.H

#ifndef NPC_H
#define NPC_H

#include "elements.h"


class npc : public elements
{
    public:
        npc();
        virtual ~npc();
        int m_y;
        static bool estDerriere(npc *a, npc *b);
    protected:
    private:
};



#endif // NPC_H

---

NPC.CPP

#include "npc.h"


npc::npc()
{
    m_y = rand()%600;
}

npc::~npc()
{

}


bool npc::estDerriere(npc *a, npc *b)
{
    return a->m_y < b->m_y;
}

---

BOMB.H

#ifndef BOMB_H
#define BOMB_H

#include "elements.h"


class bomb : public elements
{
    public:
        bomb();
        virtual ~bomb();
        int m_y;
        static bool estDerriere(bomb *a, bomb *b);
    protected:
    private:
};



#endif // BOMB_H

---

BOMB.CPP

#include "bomb.h"


bomb::bomb()
{
    m_y = rand()%600;
}

bomb::~bomb()
{

}

bool bomb::estDerriere(bomb *a, bomb *b)
{
    return a->m_y < b->m_y;
}

---

Dans le main, je fais :

    vector<npc *> m_npc;

    vector<bomb *> m_bomb;

    vector<elements *> m_elements;

    for(int i = 0; i < NB_NPC; i++)

    {

        npc *mnpc = new npc;

        m_npc.push_back(mnpc);

        cout << "NPC(" << i << ") Y : " << m_npc[i]->m_y << endl;

    }

    for(int i = 0; i < NB_BOMB; i++)

    {

        bomb *mbomb = new bomb;

        m_bomb.push_back(mbomb);

        cout << "BOMB(" << i << ") Y : " << m_bomb[i]->m_y << endl;

    }

    cout << endl << " --- ETAPE 1 : TRI DES NPC SEULEMENT --- " << endl;

    stable_sort(m_npc.begin(), m_npc.end(), npc::estDerriere);

    for(int i = 0; i < NB_NPC; i++)

    {

        cout << "NPC(" << i << ") Y : " << m_npc[i]->m_y << endl;

    }

    cout << endl << " --- ETAPE 2 : TRI DES BOMB SEULEMENT --- " << endl;

    stable_sort(m_bomb.begin(), m_bomb.end(), bomb::estDerriere);

    for(int i = 0; i < NB_BOMB; i++)

    {

        cout << "BOMB(" << i << ") Y : " << m_bomb[i]->m_y << endl;

    }

    m_elements.push_back(m_npc[0]);

    cout << endl << "adresse de m_npc[0] : " << m_npc[0] << endl;

    cout << "adresse de m_elements[0] : " << m_elements[0] << endl;

    cout << "resultat : " << m_elements[0]->m_y << endl;

    system("pause");

    for(int i = 0; i < NB_NPC; i++) delete m_npc[i];

    for(int i = 0; i < NB_BOMB; i++) delete m_bomb[i];

    return 0;

Après lancement du programme, j'obtient :

NPC(0) Y : 172
NPC(1) Y : 210
NPC(2) Y : 254
NPC(3) Y : 258
BOMB(0) Y : 145
BOMB(1) Y : 365
BOMB(2) Y : 143
BOMB(3) Y : 404

 --- ETAPE 1 : TRI DES NPC SEULEMENT ---
NPC(0) Y : 172
NPC(1) Y : 210
NPC(2) Y : 254
NPC(3) Y : 258

 --- ETAPE 2 : TRI DES BOMB SEULEMENT ---
BOMB(0) Y : 143
BOMB(1) Y : 145
BOMB(2) Y : 365
BOMB(3) Y : 404

adresse de m_npc[0] : 0x3d2528
adresse de m_elements[0] : 0x3d2528
resultat : 0
Appuyez sur une touche pour continuer...

Pourquoi mon résultat vaut-il 0 au lieu de valoir la valeure du Y de m_npc[0] ? Puisque m_elements[0] et m_npc[0] ont la même adresse, utiliser m_elements[0]->m_y revient à utiliser m_npc[0]->m_y non ??

salut
c'est normal que le resultat soit = à 0
car tes sous classes npc et bomb contiennent 2 membres m_y (celui de la classe mere et fille).
quand tu fait l'appel avec la classe mere (m_elements[0]->m_y). elle invoque son m_y qui est resté = à 0.
enleve le m_y des classe filles et ça va marcher