Yop les gens!
Voilà j'ai un petit problème, je m'explique:
J'ai une fonction int combat qui prend en compte 2vectors, qui les regroupe dans un grand vector, qui fait plein de choses ensuite (attaques, soin, sorts etc).
Et à la fin de la fonction combat, j'aimerai return la vie des personnes joueurs, j'ai donc fais:

for (x = 0; x < allVector.size(); x++)
{
if (!allVector[x].isMonster())
{
return allVector[x].getLife();
}
}

En gros, on parcourt le grand vector, et si l'élément x n'est pas un monstre, on return la vie du personnage...
ici ->
playersLife[0], playersLife[1] = combat(Players, Monsters);

Le problème c'est que le return sur playersLife[0] fait n'importe quoi et ne return jamais la bonne valeur alors que playersLife[1] correspond toujours à la vie du 2eme personnage.
Des idées? Merci d'avance

Tu peux mettre le code complet ? Ou au moins le prototype de la méthode et la déclaration des vecteurs que tu utilises ?

En tout cas mettre un return dans une boucle c'est pas très propre, tu peux pas retourner allVector.size() valeurs pour une exécution de la méthode censée en retourner une seule, c'est pas logique.
Si tu veux que ta méthode renvoie les valeurs de chaque case du vecteur, range-les d'abord dans un tableau et fais en sorte que la méthode renvoie ce tableau.

Déjà merci!
Et ensuite en gros ici on crée Players et Monsters (qui héritent de Personnage):

int playersLife[4];
vector<Monster> Monsters;
Monsters.push_back(Monster("Blob vert", 1));

vector<Player> Players;
Players.push_back(Player("gigolo1", 1));
Players.push_back(Player("gigolo2", 1));

Ensuite on fait:
playersLife[0], playersLife[1] = combat(Players, Monsters);

Et au début de combat:
vector<Personnage> allVector;

for(x=0;x<Players.size();x++)
{ allVector.push_back(playerVector[x]); }

for(x=0;x<Monsters.size();x++)
{ allVector.push_back(monsterVector[x]); }

Et du coup ta solution du tableau ça se passerai comment?
EDIT: Et le prototype de la fonction combat:
int combat(vector<Player> &Players, vector<Monster> &Monsters)

De rien

Donc tu as un vecteur de monstres de taille 1, un vecteur de joueurs de taille 2, et un vecteur de personnages (qui regroupe donc tout) de taille 3, c'est ça ? (pour ton exemple en tout cas)

J'ai un peu de mal à comprendre ce que tu cherches à faire en fait, cette double affectation et ce return au milieu d'une boucle me troublent un peu...
A priori allVector est trié donc tu n'as pas besoin de tester l'élément courant si tu connais le nombre de monstres et de personnages. Pour l'affectation, tu peux la faire dans la méthode et ne rien retourner (void) ? Quelque chose comme :
for (int i = 0; i < Players.size(); i++) { playersLife[i] = allVector[i].getLife(); }

(ce dont je parlais avec un tableau serait globalement la même chose, sauf que tu passerais par une variable locale intermédiaire que la méthode renverrait, et que tu affecterais au tableau playersLife)

Donc tu as un vecteur de monstres de taille 1, un vecteur de joueurs de taille 2, et un vecteur de personnages (qui regroupe donc tout) de taille 3, c'est ça ? (pour ton exemple en tout cas) Oui exactement ça

J'ai un peu de mal à comprendre ce que tu cherches à faire en fait En gros faire le combat (ou le joueur choisit d'attaquer telle cible, et ou le monstre attaque après etc (tour par tour) puis de retourner la vie des joueurs pour qu'au prochain combat ils "réapparaissent" avec leur vie d'avant!

cette double affectation et ce return au milieu d'une boucle me troublent un peu... C'est un peu bizarre oui, en plus ça marche pas donc j'aime pas

A priori allVector est trié donc tu n'as pas besoin de tester l'élément courant si tu connais le nombre de monstres et de personnages. C'est bien là le problème, en fait, le vector est trié selon la vitesse des membres pour que les actions s’exécutent dans le bon ordre! De plus, le nombre de monstre est certe défini au début mais ensuite il y en aura entre 1 et 4 aléatoirement à chaque fois

Pour l'affectation, tu peux la faire dans la méthode et ne rien retourner (void) ? Bah le problème c'est que c'est une autre fonction qui appelle combat donc pas possible

(ce dont je parlais avec un tableau serait globalement la même chose, sauf que tu passerais par une variable locale intermédiaire que la méthode renverrait, et que tu affecterais au tableau playersLife) Quelle serai la syntaxe du coup? playersLife[] = combat(Players, Monsters) où combat return LifePlayersAfterFight[]? Et dans le for?

Pour le tri je disais ça comme ça, ça n'a rien à voir avec ton problème je pense, c'était juste une remarque de plus pour simplifier ton code. Mais si ça ne marche pas, tant pis.

Sinon de manière générale faudrait peut-être voir la manière dont tu as conçu ton programme, les classes et les liens entre elles, la portée des variables etc... Au pire des cas si la méthode est dans une autre classe tu peux toujours créer une méthode publique (et garder les attributs privés) setLife() par exemple pour l'affectation...

Et dans le for tu ferais quelque chose comme LifePlayersAfterFight[x] = allVector[x].getLife() .
Pour l'affectation je préférerais aussi faire ça dans une boucle ensuite perso mais si y a moyen de faire directement via un tableau pourquoi pas

Ca y est j'ai trouvé une solution Alors en gros:

int playersLife[4];
for (x = 0; x < allVector.size(); x++)
{
if (allVector[x].isMonster())
{
allVector.erase(allVector.begin()+x);
}
}

for (x = 0; x < allVector.size(); x++)
{
playersLife[x] = allVector[x].getLife();
}

for (x = 0; x < Players.size(); x++)
{
Players[x].setLife(playersLife[x]);
}

On enlève tous les monstres du vector général, puis on le parcourt et on rempli un tableau de vie puis on set la vie des Players avec la tableau des vie Après le problème c'est qu'on risque de donner la mauvaise vie restante aux persos vu que l'ordre de Players et allVector est modifié, du coup bah je pense directement trier par vitesse Players avant le combat au moins c'est tout good

Mon vdd a raison, c'est tout good