Discussion :

[mazertys17]

Bonjour.

J'essaye de renvoyer plusieurs objets différents depuis une même fonction, mais cela ne semble pas fonctionner correctement. Ma facon de faire n'est probablement pas bonne. Avez vous une idée de comment il faut procéder dans ce cas là?
Merci si vous pouvez m'aider

Voici mon code:

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
 
 
 
EntiteImage Menu::renvoiEntiteImage()
{
    m_nombreImageTotal = m_nombreImageFond + m_nombreImageBouton;
 
    m_compteurImage++;
    if(m_compteurImage > m_nombreImageTotal)
    {
    m_contientImage = false;
    m_compteurImage = 0;
    }
 
 
    if(m_compteurImage <=m_nombreImageFond)
    {
    vector<Image>::iterator it= m_fond.begin();
    return it->renvoiEntiteImage();
    }
 
    if(m_compteurImage >m_nombreImageFond)
    {
    vector<Bouton>::iterator it= m_bouton.begin();
    return it->renvoiEntiteImage();
    }
 
}

-

[bacelar]

Pourquoi ne pas renvoyer un std::vector<EntiteImage> ???

[mazertys17]

Merci Mr Bacelar, pour votre réponse.

En fait mon but est de convertir les objets en EntiteImage, qui ne contient que les informations nécessaire à l'affichage. Voila pourquoi je n'envoi pas des vectors, qui peuvent aussi bien être des vector<Image> que vector <Perssonage1> etc...mais simplement une EntiteImage, qui est la même pour tous. C'est pour cela que j'ai besoin de faire plusieurs return différents.

[Bousk]

Salut,

reprenons les bases du C++
1 fonction = 1 return
le return se fait toujours par copie, sauf s'il s'agit d'une référence
partant de là, vouloir "faire plusieurs return" ne veut rien dire et est strictement impossible.
le return est typé, donc une fonction qui "retourne Image, mais aussi Personnage", "parfois l'un, parfois l'autre" est impossible (sauf à partir dans du hack à base de Any etc... bref faut pas)
on peut éventuellement envisager du template selon le cas

Si tu veux retourner plusieurs valeurs du même type : vector
Si tu veux retourner plusieurs valeurs de type différent : aggrégation en struct ?

Dans tous les cas, ton idée semble mauvaise et cache certainement une conception bancale.

[jblecanard]

Si tu veux retourner plusieurs valeurs de type différent : aggrégation en struct ?

std::stuple, à utiliser en combo avec std::tie (et std::ignore si besoin).

[mazertys17]

Bousk, merci pour votre réponse, bien qu'un peut agressive

Oui, bien entendu, une fonction ne renvoi qu'une seule chose. Si vous aviez lu mon code, vous auriez certainement vu que vous avez mal compris ma question qui, je le reconnais, n'est pas des mieux formulé

Je parle ici de condition. dans mon cas, il s'agit d'un compteur d'image:

ex: si le compteur est < x, alors renvoi Objet1->truck, s'il est supérieur à x, renvoi Objet2->truck...

Cela marche sans aucun problème s'il s'agit de simple variables ou même objets...Mais mon problème arrive dès qu'il s'agit de renvoyer un objet contenu dans un vector<Objet>...

Voila...

[ternel]

En fait, ton code ressemble à ceci:

Code :

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

1
2
3
4
int f(int arg) {
    if (arg == 0) return 0;
    if (arg > 0) return 1;
}

Quelle est la valeur de retour si l'argument est -1?

[mazertys17]

Quelle est la valeur de retour si l'argument est -1?

Disons qu'elle n'est pas censé l'être, puisqu'il s'agit d'un compteur, qu'il est initialisé à zéro, et qu'il ne fait que monter...

Je me suis dit que la meilleur solution dans mon cas, est(un peut comme dit Bousk), de créer un pointeur EntiteImage *entiteImageRelai qui prendrait la valeur de l'image concerné. Cela permet, de plus, d'avoir la sécurité, si l'argument est de -1, par ex. (cependant, dans mes test, il ne semble pas le prendre en compte) Pensez vous qu'il s'agisse d'une bonne solution ?

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
 
 
 
EntiteImage Afficheur::renvoiEntiteImage()
{
    m_contienImage = false; //un bool pour dire s'il a des images à envoyer...
    *m_entiteRelai = m_image->renvoiEntiteImage(); //ici, donc la sécurité pour renvoyer quoiqu'il arrive quelque chose(mais ne marche pas?)
 
    switch (m_jeu)
    {
    case 0:
        m_contienImage = m_menu->contientImage();
        *m_entiteRelai = m_menu->renvoiEntiteImage()+m_compteurImage;
        break;
    case 1:
        m_contienImage = m_niveau1->contientImage();
        *m_entiteRelai = m_niveau1->renvoiEntiteImage()+m_compteurImage;
        break;
    }
 
    return *m_entiteRelai;
}

[Bousk]

Code :

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

bool Afficheur::renvoiEntiteImage(EntiteImage* _img)

ou

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
EntiteImage Afficheur::renvoiEntiteImage()
{
    switch (m_jeu)
    {
    case 0:
        return m_menu->renvoiEntiteImage()+m_compteurImage;
        break;
    case 1:
        return m_niveau1->renvoiEntiteImage()+m_compteurImage;
        break;
    }
    throw Exception("Bad call");
}

edit:
en plus c'est quoi cette syntaxe m_niveau1->renvoiEntiteImage()+m_compteurImage; ?
C'est sensé retourner un EntiteImage sur un operator+ ? Par copie ?

[mazertys17]

Oui.
Comme je l'ai dit plus haut, mon but est de n'envoyer que l'objet "EntiteImage" contenu dans chaque Objet mère ("Image", "Bouton", "Personage1" etc...par ex...) a un afficheur, qui se contentera de les afficher quelque soit leur provenance...Peut être n'est-ce pas la meilleur solution du monde, mais ca marche. Je me questionne encore d'ailleurs sur le fait d'envoyer un pointeur "EntiteImage" ou un objet "EntiteImage", sachant que l'objet "EntiteImage" contient un pointeur sur une texture et un VertexArray quad (avec la SFML)...

Pour votre code...c'est Juste...mais je cherche a faire ceci:

Code :

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

1
2
3
4
5
6
 
 
    case 2:
        vector<Image>::iterator it = m_monImage.begin()+compteurImage;
        return it->renvoiEntiteImage();
        break;

Ce qui, sauf erreur, ne marche pas...

J'ai donc finalement pris, n'ayant pas de solution concrètes, le partie de faire:

dans ma class:

Code :

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

1
2
3
4
5
6
7
8
9
 
    ...
protected:
    ...
    EntiteImage *m_entiteRelai;
    ...
    vector<Bouton> m_bouton;
    vector<Bouton>::iterator m_itBouton = m_bouton.begin();
    ...

et dans ma 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
16
17
18
19
20
21
22
23
24
 
    //ici l'envoi de l'image de fond.
    // Un "compteurPrive" de bouton est calculé en fonction des images qu'il y a eu avant.
    ...
    if(m_compteurImage > m_nombreImageFond)
    {
    m_itBouton = m_bouton.begin()+m_ccompteurBoutonPrive;
    m_ccompteurBoutonPrive++;
    m_controleur = 2;
    }
    ...
    ...
    switch (m_controleur)
    {
    case 1:
        *m_entiteRelai = fond->renvoiEntiteImage();
       // return fond->renvoiEntiteImage();
        break;
    case 2:
        *m_entiteRelai = m_itBouton->renvoiEntiteImage();
 
         //return *it->renvoiEntiteImage();
        break;
    }

Qu'en pensez vous?

j'ai une autre question a poser: est-il dangereux de mettre un ittérator en attribut privé??

Merci

[ternel]

Que penses-tu de passer par l'accès direct?

Code :

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

case 2: return m_monImage.at(compteurImage).renvoiEntiteImage();

ou si tu peux garantir le compteur

Code :

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

case 2: return m_monImage[compteurImage].renvoiEntiteImage();

regarde donc la documentation de la fonction

Au passage, return quittant la fonction, il quitte aussi ton switch, rendant le break inutile.