[Débutant]Vecteur de pointeurs

**@r$£~%[** · 08/08/2005, 11h45

Bonjours à tous,

J' aimerais créer un vecteur de tableau (Edit : Un vecteur de pointeur, pardon) ... Comment faire?

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
    int i = 10;
    int j = 20;
    int k = 30;
 
    vector<int> Tableau;
    Tableau.push_back( &i );
    Tableau.push_back( &j );
    Tableau.push_back( &k );
 
    cout << "Les nombres sont : " << Tableau.pop_back() << ", " << Tableau.pop_back() << " et " << 
         Tableau.pop_back();
 
    system("PAUSE");
 
    return 0;

**10_GOTO_10** · 08/08/2005, 11h50

Code :

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

vector<int *>

Tout simplement, non ?

**@r$£~%[** · 08/08/2005, 11h56

J' avais essayé avec vector<*int>, et le compilos m'a répondu qu' il ne devait pas y avoir d' opérateur * entre chevrons... Mais quand j' essaie de compiler avec
vector<int *>, le compilos me répond :

G:\Dev-Cpp\temp.cpp:17: error: no match for 'operator<<' in 'std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(&std::cout)), ((const char*)"Les nombres sont : ")) << (&Tableau)->std::vector<_Tp, _Alloc>::pop_back [with _Tp = int*, _Alloc = std::allocator<int*>]()'
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:63: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>&(*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:74: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>&(*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:86: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base&(*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:121: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:155: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:98: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:178: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:189: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:193: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:204: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:179: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:214: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:238: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:219: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:261: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]

G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:284: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:307: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:449: note: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, char) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:505: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, char) [with _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:460: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, signed char) [with _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:465: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, unsigned char) [with _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:567: note: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const char*) [with _CharT = char, _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/bits/ostream.tcc:612: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:499: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const signed char*) [with _Traits = std::char_traits<char>]
G:/Dev-Cpp/include/c++/3.4.2/ostream:504: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const unsigned char*) [with _Traits = std::char_traits<char>]

Exécution terminée

**Laurent Gomila** · 08/08/2005, 12h10

pop_back() ne renvoie rien, c'est back() qui renvoie une référence sur le dernier élément.

Mais si tu veux afficher tous les éléments, il faudra plutôt parcourir ton tableau via un compteur ou un itérateur.

**@r$£~%[** · 08/08/2005, 12h16

Oui, j' essaie de créer une petite classe application SDL, et j' aimerais que le déstructeur de cette classe détruise toute les instances de la classes Surface...

Je comptait créer un vector globale où chaque constructeur de Surface mettrait this par réference...

Y a-t-il plus simple?

Edit : Et comment faire pour parcourir un tableau à l' aide d' un iterateur

**Laurent Gomila** · 08/08/2005, 13h01

Oui, j' essaie de créer une petite classe application SDL, et j' aimerais que le déstructeur de cette classe détruise toute les instances de la classes Surface...

Je comptait créer un vector globale où chaque constructeur de Surface mettrait this par réference...

Y a-t-il plus simple?

C'est une solution, mais pour pinailler ça ne me paraît pas la meilleure. Tout d'abord ton vecteur global ne doit pas l'être : il vaudra mieux le mettre en donnée membre de la classe qui va gérer les surfaces, à savoir très probablement ta classe Application. Mais là ça pose un problème pour l'ajout (les classes Surface ne sont pas censées avoir connaissance de la classe Application et de son tableau de surfaces).

Il vaut mieux avoir une meilleure gestion des surfaces au niveau de la durée de vie (objets automatiques, pointeurs intelligents, ...) et les laisser se détruire tous seuls le moment venu.

Edit : Et comment faire pour parcourir un tableau à l' aide d' un iterateur

Code :

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

1
2
3
4
for (std::vector<Truc>::iterator i = tableau.begin(); i != tableau.end(); ++i)
{
    FaireQuelqueChoseAvec(*i);
}

Tu peux faire un peu de recherche avec Google pour plus de détails.

**@r$£~%[** · 08/08/2005, 17h38

Il vaut mieux avoir une meilleure gestion des surfaces au niveau de la durée de vie (objets automatiques, pointeurs intelligents, ...) et les laisser se détruire tous seuls le moment venu.

Ce n' est pas tellement la durée de vie qui pose probléme, en fait. Je peux inclure une réference sur le SDL_Surface dans la classe surface et le libérer dans le destructeur. Mais je doit, lors du rafraichissement de l' ecran, coller tout les surfaces sur l' ecran... J' ai donc besoins d' avoir accés à toute les instances de la classes.

Est-il possible de défnir une surcharge d' opérateur statique...

Si oui, je crois que je vais créer un vecteur statique à la classe et définir le constructeur pour qu' il ajoute une réference sur l' objet this dans le tableau. Puis, je vais sucharger l' opérateur crochet [] avec un entier pour qu' il renvoie la réference de l' objet visé.

Est-ce fesable?

**Laurent Gomila** · 09/08/2005, 11h52

Est-il possible de défnir une surcharge d' opérateur statique...

Non, c'est impossible.

Ce n' est pas tellement la durée de vie qui pose probléme, en fait. Je peux inclure une réference sur le SDL_Surface dans la classe surface et le libérer dans le destructeur. Mais je doit, lors du rafraichissement de l' ecran, coller tout les surfaces sur l' ecran... J' ai donc besoins d' avoir accés à toute les instances de la classes

Oui effectivement. Quand je parlais de durée de vie, je voulais dire "qui va gérer la création, la gestion et la destruction des instances de Surface ?". Vu qu'elles ne peuvent pas se gérer toutes seules (ie. elle doivent être utilisées par une entité de plus haut niveau), il faut donc que tu les stockes / crées / detruisent au niveau de ta classe Application (ou SurfaceManager, ou n'importe quoi d'autre qui soit approprié dans ton design de classes). Afin de ne pas avoir de références croisées (Application a une liste de Surface, et Surface connait la liste de Application) je pense qu'il vaut mieux s'interfacer avec tes surfaces via la classe englobante, par exemple :

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
class Application
{
public :
 
    Surface* CreateSurface(...)
    {
        Surface* s = new Surface(...);
        mySurfaces.insert(s);
        return s;
    }
 
    void RemoveSurface(Surface* s)
    {
        mySurfaces.erase(s);
        delete s;
    }
 
    void Refresh()
    {
        std::for_each(mySurfaces.begin(), mySurfaces.end(), std::mem_fun(&Surface::Draw));
    }
 
private :
 
    std::set<Surface*> mySurfaces;
};

**@r$£~%[** · 09/08/2005, 12h05

Merci... Je crois que je vais faire comme ça.

Mais je ne comprend pas bien cette portion de code...
La STL, c' est pas mon fort

Code :

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

1
2
3
4
5
6
7
8
    void Refresh()
    {
        std::for_each(mySurfaces.begin(), mySurfaces.end(), std::mem_fun(&Surface::Draw));
    }
 
private :
 
    std::set<Surface*> mySurfaces;

La fonction foreach execute une fonctions sur toute les entrées d' un conteneur?

**Laurent Gomila** · 09/08/2005, 12h20

Oui, ce genre de syntaxe est toujours difficile à assimiler au début

Comme tu l'as deviné, for_each sert bien à appliquer une fonction à chaque élément d'un conteneur. Puisqu'ici nous voulons appeler une fonction membre des éléments, on passe par l'adaptateur mem_fun.

Bon c'était juste pour l'exemple, si tu préfères passer par une boucle ce ne sera pas tragique

.

**@r$£~%[** · 09/08/2005, 13h00

Non, c' est bon... Je vais essayer de faire comme ça... Mais qu' est ce que le conteneur set?

**Laurent Gomila** · 09/08/2005, 13h18

std::set est un conteneur trié n'acceptant pas de doublon. Ca permet entre autre d'avoir une insertion, une recherche et une suppression en temps logarithmiques.

**@r$£~%[** · 09/08/2005, 13h20

Merci pour toute les infos... Je reviens si j' ai un probléme.

**@r$£~%[** · 09/08/2005, 14h01

Mais comment faire pour exécuter application::RemoveSurface() sur toute les surfaces de mon Set (pour le déstructeur de application)

**Laurent Gomila** · 09/08/2005, 14h08

Il ne faut pas appeler RemoveSurface sur tous les éléments de ton set. Ca va au fur et à mesure les supprimer de celui-ci, et mettre le boxon dans ton parcours.

Dans ton destructeur, tu peux utiliser une simple boucle pour faire un delete sur chaque élément, ou si tu veux utiliser for_each tu as un bon exemple du foncteur qui va bien dans la FAQ.

http://c.developpez.com/faq/cpp/?pag...elete_sequence

Pour pousser encore plus loin, le must serait d'utiliser un pointeur intelligent et de le laisser faire tranquillement son boulot

**@r$£~%[** · 09/08/2005, 14h20

Pour pousser encore plus loin, le must serait d'utiliser un pointeur intelligent et de le laisser faire tranquillement son boulot Wink

N' en demande pas trop...

Mais je dois mettre la classe application amie avec surface, puisque je ne vais pas mettre Draw en publique... Non?

**Laurent Gomila** · 09/08/2005, 14h46

Envoyé par @r$£~%[

Mais je dois mettre la classe application amie avec surface, puisque je ne vais pas mettre Draw en publique... Non?

Ca c'est un détail, après il faut faire quelque chose qui colle avec ton design de classes. A vue de nez, je dirais qu'ici il n'est pas primordial de cacher Surface:

raw et de mettre Surface en amie de Application.