Discussion :

[insane97]

Salut
Je suis en train de faire des tests avec la STL et je rencontre un petit problème, je sais pas si j'ai manqué quelque chose, mais j'aurais voulu savoir

J'utilise

Code :

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

std::deque<carte*>

et je voudrais comparée deux ojet de ce type mais la où sa coince c'est que les objets stockés à l'interieur sont des pointeurs

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
    std::deque<carte*> *j = new std::deque<carte*>;
    j->push_back(new carte(1,1));
    j->push_back(new carte(2,1));
 
    std::deque<carte*> *k = new std::deque<carte*>;
    k->push_back(new carte(1,1));
    k->push_back(new carte(2,1));
 
    std::deque<carte*> *l = new std::deque<carte*>;
    l->push_back(new carte(1,1));
    l->push_back(new carte(3,1));
 
    if(*j==*k)
        std::cout << "j egale k" << std::endl;
    else std::cout << "j diff k" << std::endl;
 
    if(*j==*l)
        std::cout << "j egale l" << std::endl;
    else std::cout << "j diff l" << std::endl;
 
    delete j; delete k; delete l;

J'ai sa

Code :

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

1
2
3
console:
j diff k //note: au lieu de j egale k
j diff l

Donc a priori ici l'operator== compare les adresse des pointeurs mais n'apelle pas l'operator== de carte, comment faire pour l'appeler, dois-je passer par une derivation de std::deque<T> ?

[ternel]

tu n'as pas besoin de faire des pointeur de vecteur.

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
    std::deque<carte*> j, k, l;
    j.push_back(new carte(1,1));
    j.push_back(new carte(2,1));
 
    k.push_back(new carte(1,1));
    k.push_back(new carte(2,1));
 
    l.push_back(new carte(1,1));
    l.push_back(new carte(3,1));
 
    if(j==k)
        std::cout << "j egale k" << std::endl;
    else std::cout << "j diff k" << std::endl;
 
    if(j==l)
        std::cout << "j egale l" << std::endl;
    else std::cout << "j diff l" << std::endl;

Si tu n'as pas d'héritage dans les cartes, comme ca a l'air présentement, tu peux meme utiliser des vecteurs de cartes (si elles sont copiables)

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
    std::deque<carte> j, k, l;
    j.push_back(carte(1,1));
    j.push_back(carte(2,1));
 
    k.push_back(carte(1,1));
    k.push_back(carte(2,1));
 
    l.push_back(carte(1,1));
    l.push_back(carte(3,1));
 
    if(j==k)
        std::cout << "j egale k" << std::endl;
    else std::cout << "j diff k" << std::endl;
 
    if(j==l)
        std::cout << "j egale l" << std::endl;
    else std::cout << "j diff l" << std::endl;

Dans l'autre cas, il faut que tu libères manuellement les pointeurs alloués par chaque new carte(). regarde cette entrée de la faq


Dans tous les cas. l'égalité de vecteur n'est pas à tester ainsi.
il vaut mieux passer par std::equal(j.begin(), j.end(), k.begin(), k.end()), equal est définit dans <algorithm>

PS: Pour ton usage, j'aurai plutot utilisé un std::set<carte>, pour garantir à la fois l'unicité des cartes et leur tri.

[cob59]

Il y a bien trop d'alloc dynamique dans ce code !
L'équivalent en alloc statique -- et en s'assurant que 'carte' se copie/déplace correctement -- devrait fonctionner plus simplement :

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
std::deque<carte> j;
j.push_back(carte(1,1));
j.push_back(carte(2,1));
 
std::deque<carte> k;
k.push_back(carte(1,1));
k.push_back(carte(2,1));
 
std::deque<carte> l;
l.push_back(carte(1,1));
l.push_back(carte(3,1));
 
if(j==k)
	std::cout << "j egale k" << std::endl;
else std::cout << "j diff k" << std::endl;
 
if(j==l)
	std::cout << "j egale l" << std::endl;
else std::cout << "j diff l" << std::endl;

En plus cela aurait l'avantage de désallouer automatiquement les cartes qui, pour l'instant, provoquent des fuites de mémoire.

[edit] Devancé par leternel.

[insane97]

Merci pour ta reponse,
En faite, les pointeurs (std::deque<T> *) c'etait pour reprendre les conditions de mon autre code, les deques etant des variables membres, car celui la etait juste pour tester.

Etant donné que j'utilise donc des pointeurs (std::deque<T> *) ne vaut-il pas mieux de remplacer T par T* ?

Et merci pour le

Code :

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

std::equal

je connaissai pas, faudrait que je plonge un peu dans

Code :

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

<algorithm>

Sinon selon ce site http://en.cppreference.com/w/cpp/algorithm/equal, la fonction equal que tu m'as montrer (les arguments) n'es pas suporté, non ?

[ternel]

Tu as deux problèmes distincts: "collection de valeur ou de pointeur", et "valeur ou pointeur de collection"

Pour les valeurs:
En gros, si tes collectés sont copiables et non hérités, alors un deque de valeur est possible. Ce n'est un bon choix que s'ils sont en plus petits (sinon, préferer une list ou des pointeurs quand meme)

Si les collectés sont non-copiables (et non déplacables en c++11) ou ont besoin d'être polymorphiques (de profiter des méthodes virtuelles), alors il faut utiliser des pointeurs.
Sinon, tu souffriras du "slicing", c'est à dire que les valeurs seront coupés, malgré le type initial.

À présent, la question de pointer la collection.

Un pointeur en moins est une montagne d'erreurs en moins.

Si tu as besoin de ne pas copier une collection, utilise une référence, probablement constante.
En première approche, considère qu'il ne faut manier des pointeurs que pour deux situations:

• permettre à une chose de ne pas exister (late initialisation)
• permettre l'allocation dynamique manuelle (sinon, préférer std/boost::unique_ptr)

Un pointeur ne devrait pas, en principe, être un argument de fonction, il y a les références pour ca.

Mieux encore, autant que possible, donne accès aux itérateurs plutôt qu'à la collection.
Ainsi, tu ne donne pas d'accès public au fait que la classe contienne un deque. Comme ca, si ca doit devenir un set ou une liste, ce sera de la tambouille interne, sans impact sur le reste du programme