[Débutant]Vecteur de pointeurs

Version imprimable

Bonjours à tous,

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

Code:

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;

08/08/2005, 11h50
10_GOTO_10

Code:

vector<int *>

Tout simplement, non ?
08/08/2005, 11h56
@r$£~%[

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 :

Citation:

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
08/08/2005, 12h10
Laurent Gomila

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.
08/08/2005, 12h16
@r$£~%[

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
08/08/2005, 13h01
Laurent Gomila
Citation:

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.

Citation:

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

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.
08/08/2005, 17h38
@r$£~%[

Citation:

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?

Citation:

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

Non, c'est impossible.

Citation:

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:

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; };

09/08/2005, 12h05
@r$£~%[
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 :oops:
Code:

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?
09/08/2005, 12h20
Laurent Gomila

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

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 :wink:.
09/08/2005, 13h00
@r$£~%[

Non, c' est bon... Je vais essayer de faire comme ça... Mais qu' est ce que le conteneur set?
09/08/2005, 13h18
Laurent Gomila

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.
09/08/2005, 13h20
@r$£~%[

Merci pour toute les infos... Je reviens si j' ai un probléme.
09/08/2005, 14h01
@r$£~%[

Mais comment faire pour exécuter application::RemoveSurface() sur toute les surfaces de mon Set (pour le déstructeur de application)
09/08/2005, 14h08
Laurent Gomila

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 :wink:
09/08/2005, 14h20
@r$£~%[

Citation:

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... :D

Mais je dois mettre la classe application amie avec surface, puisque je ne vais pas mettre Draw en publique... Non?
09/08/2005, 14h46
Laurent Gomila

Citation:

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::Draw et de mettre Surface en amie de Application.
09/08/2005, 15h50
@r$£~%[

Qu' entend-tu exactement par design de classe... La façon dont je crée mes classes et les interactions qu' elle ont entre elles?
09/08/2005, 16h19
Laurent Gomila

Oui, c'est en gros ça.